index-edit.html

<!doctype html>
<html lang="en">

<head>
  <meta charset="utf-8">

  <title>Wizard Class</title>

  <!--meta name="description" content=""-->
  <meta name="author" content="Ryan Skonnord">

  <meta name="apple-mobile-web-app-capable" content="yes"/>
  <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent"/>

  <meta name="viewport"
        content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, minimal-ui">

  <link rel="stylesheet" href="css/reveal.css">
  <link rel="stylesheet" href="css/theme/sky.css" id="theme">

  <!-- Code syntax highlighting -->
  <link rel="stylesheet" href="lib/css/zenburn.css">

  <style>
    section.bigcode {
    width: 1440px !important;
    margin-left: -240px
    }

    section.bigcode code {
    max-height: 600px;
    }
  </style>

  <!-- Printing and PDF exports -->
  <script>
    var link = document.createElement('link');
    link.rel = 'stylesheet';
    link.type = 'text/css';
    link.href = window.location.search.match(/print-pdf/gi) ? 'css/print/pdf.css' : 'css/print/paper.css';
    document.getElementsByTagName('head')[0].appendChild(link);


  </script>

  <!--[if lt IE 9]>
  <script src="lib/js/html5shiv.js"></script>
  <![endif]-->
</head>

<body>

<div class="reveal">

  <!-- Any section element inside of this container is displayed as a slide -->
  <div class="slides">

    <section>
      <h1>Wizard Class</h1>
      <h4>with <a href="mailto:ryanskonnord@gmail.com">Ryan Skonnord</a></h4>
    </section>
    <section>
      <section>
        <h2>The Wizard Book</h2>
      </section>
      <section>
        <p>In 1985, some MIT professors wrote <i>Structure and Interpretation of Computer Programs</i>, known informally
          as "SICP" or "the Wizard Book".</p>

        <p class="fragment">This textbook was used for the introductory computer science course at MIT and UC Berkeley
          for decades.</p>

        <p class="fragment">An e-book edition is <a href="https://mitpress.mit.edu/sicp/">available for free</a> and
          licensed under
          <a href="http://creativecommons.org/licenses/by-sa/4.0/">Creative Commons BY-SA</a>.</p>
      </section>
      <section>
        <img src="sicp-cover.jpg" alt="Structure and Interpretation of Computer Programs"/>
      </section>
      <section>
        <p>My lecturer remarked (I'm paraphrasing) that, to this day, it covers the entire discipline of computer
          science, aside from implementation details.</p>

        <p class="fragment">It uses basic, but very elegant and powerful, concepts to explain a wide variety of topics
          in programming.</p>

        <p class="fragment">These concepts are expressed in the language Scheme, a dialect of Lisp.</p>
      </section>
      <section>
        <h3>Why wizards?</h3>
        <blockquote>
          &ldquo;A computational process is indeed much like a sorcerer's idea of a spirit. It cannot be seen or
          touched. It is not composed of matter at all. However, it is very real. It can perform intellectual work. It
          can answer questions. It can affect the world...
        </blockquote>
      </section>

      <section>
        <h3>Why wizards?</h3>
        <blockquote cite="https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-9.html">
          &ldquo;The programs we use to conjure processes are like a sorcerer's spells. They are carefully composed from
          symbolic expressions in arcane and esoteric programming languages that prescribe the tasks we want our
          processes to perform.&rdquo;
          <br/>&mdash;<a href="https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-9.html"><i>SICP</i>, Chapter 1</a>
        </blockquote>
      </section>

      <section>
        <p>A central theme of the book: code is data.</p>
        <blockquote>&ldquo;It is no exaggeration to regard this as the most fundamental idea in programming: The
          evaluator, which determines the meaning of expressions in a programming language, is just another program.&rdquo;
          <br/>&mdash;<a href="https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-25.html"><i>SICP</i>, Chapter 4</a>
        </blockquote>
        <p class="fragment">To illustrate this idea, the book spends a chapter implementing a Scheme interpreter in
          Scheme.</p>
      </section>
    </section>

    <section>
      <section>
        <h2>What are we doing here?</h2>
      </section>

      <section>
        <p>Let's do something similar: build an abstract programming tool out of more basic, but elegant,
          abstractions.</p>

        <p class="fragment">I was inspired by something that the faculty at Berkeley had added on to the course
          material: a library of macros that extended Scheme with object-oriented features.</p>

        <p class="fragment">Let's make our own classes.</p>
      </section>

      <section>
        <p>You might think of classes as magic: something that the programming language has to provide to us as a
          feature.</p>

        <p class="fragment">But, if a programmer is a wizard, you shouldn't be afraid to make your own magic.</p>
      </section>

      <section class="bigcode">
        <code class="ruby" data-file="code/goal.rb"></code>
      </section>
    </section>

    <section>
      <h2>Arcane Musings</h2>
    </section>

    <section>
      <section>
        <h3>Definition of an object</h3>

        <p>An object has</p>

        <ul>
          <li>State</li>
          <li>Behavior</li>
        </ul>
      </section>

      <section>
        <h3>Definition of object-oriented programming</h3>

        <p>Uses objects with the properties of:</p>

        <ul>
          <li><strong>Encapsulation</strong>
            <ul>
              <li class="fragment">State that governs behavior is bundled up inside one object.</li>
              <li class="fragment">Includes, but does not require, <strong>information hiding</strong>.</li>
            </ul>
          </li>
          <li><strong>Polymorphism</strong>
            <ul>
              <li class="fragment">Multiple types of object that share behavior can be referred to with one common
                interface.
              </li>
            </ul>
          </li>
          <li><strong>Inheritance</strong>
            <ul>
              <li class="fragment">Subclasses can extend a class, keeping the parent's state and behavior while adding
                their own.
              </li>
            </ul>
          </li>
        </ul>
      </section>
    </section>
    <section>
      <section>
        <h3>Definition of a class</h3>

        <ul>
          <li>A class defines the state and behavior that are common to a group of objects.</li>
          <li class="fragment">A class is an object!</li>
          <li class="fragment">The purpose of the class object is to construct other objects.
            <ul>
              <li class="fragment">This is called <em>instantiating</em> the class.</li>
              <li class="fragment">The object made is called an <em>instance</em> of the class.</li>
            </ul>
          </li>
        </ul>
      </section>
      <section>
        <h3>Semantics</h3>

        <p>Many languages don't model classes as objects.</p>

        <p class="fragment">Many programmers use "object" and "instance" interchangeably.</p>

        <p class="fragment">For that matter, many programmers use "instantiate" and "construct" interchangeably.</p>
      </section>
      <section>
        <p>However, classes-as-objects isn't just an academic concept.</p>

        <p class="fragment">This is very relevant if you use any of the metaprogramming features
          <a href="http://stackoverflow.com/a/6581949">in Python</a> or
          <a href="https://rubymonk.com/learning/books/2-metaprogramming-ruby">in Ruby.</a>
        </p>
      </section>
    </section>
    <section>
      <section>
        <h3>Encapsulation, Lisp-style</h3>

        <p>Before OOP became a buzzword, the Wizard Book used the term
          "<a href="https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-13.html">data abstraction</a>"
          to describe almost the same concept as encapsulation.</p>

        <code class="python"><pre>def make_rectangle(length, width):
    return {'length': length, 'width': width}
def get_perimeter(rectangle):
    return 2 * (rectangle['length'] + rectangle['width'])
def get_area(rectangle):
    return rectangle['length'] * rectangle['width']

my_rectangle = make_rectangle(3, 5)
print('Perimeter is:', get_perimeter(my_rectangle))
print('Area is:', get_area(my_rectangle))</pre>
        </code>
      </section>
      <section>
        <h3>Encapsulation, Lisp-style</h3>

        <code class="python"><pre>def make_rectangle(length, width):
    return {'length': length, 'width': width}
def get_perimeter(rectangle):
    return 2 * (rectangle['length'] + rectangle['width'])
def get_area(rectangle):
    return rectangle['length'] * rectangle['width']

my_rectangle = make_rectangle(3, 5)
print('Perimeter is:', get_perimeter(my_rectangle))
print('Area is:', get_area(my_rectangle))</pre>
        </code>
        <ul>
          <li>Define a set of functions to create and act on an object.</li>
          <li class="fragment">In those functions, "privately" use any data structure you want to represent the object.
          </li>
          <li class="fragment">"Outsider" code uses those functions exclusively, and is agnostic to the data structure.
          </li>
        </ul>

      </section>
      <section>
        <h3>Encapsulation, Lisp-style</h3>

        <code class="python"><pre># RIGHT
print('Perimeter is:', get_perimeter(my_rectangle))
print('Area is:', get_area(my_rectangle))

# WRONG - Breaks encapsulation
print('Perimeter is:', my_rectangle['perimeter'])
print('Area is:', my_rectangle['area'])
	  </pre>
        </code>
        <ul>
          <li class="fragment">Ignoring the private implementation details is a matter of convention.</li>
          <li class="fragment">A failure in such discipline is called "violating the data abstraction".</li>
          <li class="fragment">In a class whose textbook is <i>SICP</i>, this loses you homework points.</li>
        </ul>

      </section>
      <section>
        <h3>Encapsulation, Lisp-style</h3>

        <p>If you do it right, you can swap out the functions' private behavior and everything that
          uses them will work
          the same.</p>

        <code class="python"><pre>def make_rectangle(length, width):
    return {'olinguito': length, 'keeshond': width}
def get_perimeter(rectangle):
    return 2 * (rectangle['olinguito'] + rectangle['keeshond'])
def get_area(rectangle):
    return rectangle['olinguito'] * rectangle['keeshond']

my_rectangle = make_rectangle(3, 5)
print('Perimeter is:', get_perimeter(my_rectangle))
print('Area is:', get_area(my_rectangle))</pre>
        </code>
      </section>
    </section>
    <section>
      <section>
        <h3>First-class functions</h3>

        <code class="python"><pre>def square(x):
    return x * x

def apply_twice_and_print(function, argument):
    result = function(argument)
    result = function(result)
    print(result)

apply_twice_and_print(square, 4)</pre>
        </code>
      </section>
      <section>
        <h3>First-class functions</h3>

        <p>A more realistic example: callbacks.</p>

        <code class="javascript"><pre>$("button").click(function() {
    $.ajax({
        url: "http://example.com/my-service",

        success: function(result, status, xhr) {
            var formatted = formatResult(result);
            $("#display").html(formatted);
        },

        error: function(xhr, status, error) {
            $("#display").html(sadFace);
            alert(error );
        }
    });
});</pre>
        </code>

      </section>
    </section>
    <section>
      <section>
        <h3>Message passing</h3>

        <p>Data abstractions + First-class functions = Power</p>

        <p class="fragment">The <strong>message passing</strong> pattern gives us a way to bundle up both state and
          multiple kinds of behavior in a single first-class value.</p>

      </section>
      <section>
        <h3>Message passing in Python</h3>

        <code class="python"><pre>def make_rectangle(length, width):

    def receive_message(message):
        if message == 'get_perimeter':
            return 2 * (length + width)
        if message == 'get_area':
            return length * width
        else: raise

    return receive_message

def get_perimeter(rectangle):
    return rectangle('get_perimeter')
def get_area(rectangle):
    return rectangle('get_area')

small_rectangle = make_rectangle(3, 5)
big_rectangle = make_rectangle(30, 50)
print(get_area(small_rectangle), get_area(big_rectangle))</pre>
        </code>

	<ul>
	  <li class="fragment">Something very important has changed here.</li>
	  <li class="fragment">The calculation logic has moved from the "get" functions to the object itself.</li>
	</ul>
      </section>
      <section>
        <p>Message passing isn't the kind of design pattern you use in everyday coding, but it's really what happens
          under the covers of your favorite OOP language.</p>

        <p class="fragment">In fact, you don't generally write your own message-passing functions because OOP represents
          it so elegantly that you don't think about it.</p>
      </section>
      <section>
        <p>You shouldn't be writing code in an object-oriented language that looks like this.</p>
        <code class="java"><pre>  public void update(String message, Record record) {
    if (message.equals("markAsActive")) {
      // ...
    } else if (message.equals("markAsInactive")) {
      // ...
    } else if (message.equals("delete")) {
      // ...
    }
  }</pre>
        </code>

        <p class="fragment">It will not pass code review.</p>
      </section>
      <section>
        <p>Message passing gives us encapsulation: data is bundled with behavior.</p>

        <p class="fragment">Message passing gives us polymorphism: you can create different types of object that
          recognize common messages.</p>

        <p class="fragment">We're two thirds of the way there!</p>
      </section>
    </section>
    <section>
      <section>
        <h3>Closures</h3>

        <ul>
          <li>The rectangle functions were able to store information about their length and width.</li>
          <li class="fragment">Different instances of the function stored different values.</li>
          <li class="fragment">This is because they are not merely functions, but <strong>closures</strong>.</li>
          <li class="fragment">A closure is a function that holds on to a reference to the variables that existed when
            it was defined (its "environment").
          </li>
        </ul>

      </section>
      <section>
        <h3>Closures in languages</h3>

        <table>
          <tr>
            <th>Language</th>
            <th>First-class functions?</th>
            <th>Lambdas?</th>
            <th>Closures?</th>
          </tr>
          <tr>
            <td>Python, Ruby, JavaScript</td>
            <td>Yes</td>
            <td>Yes</td>
            <td>Yes</td>
          </tr>
          <tr>
            <td>C</td>
            <td>Sort of</td>
            <td>No</td>
            <td>No</td>
          </tr>
          <tr>
            <td>Java</td>
            <td>Fakes it pretty well</td>
            <td>In Java 8,<br/>yes</td>
            <td>Fakes it awkwardly</td>
          </tr>
        </table>
      </section>

      <section>
        <h3>Java's faux closures</h3>

        <p>In Java, what you see is this:</p>
        <code class="java"><pre>  public long getCount(final String name) {
    return hibernateTemplate.execute(new HibernateCallback&lt;Long&gt;() {
      @Override public Long doInHibernate(Session session) throws HibernateException, SQLException {
        Query query = session.createQuery("select count(*) from Thing where name=:name");
        query.setParameter("name", name);
        return (Long) query.uniqueResult();
      }
    });
  }</pre>
        </code></section>
      <section>
        <p>What it's actually doing is this:</p>
        <code class="java"><pre>  public long getCount(final String name) {
    return hibernateTemplate.execute(new InvisibleAnonymousClass(name));
  }

  private class InvisibleAnonymousClass implements HibernateCallback&lt;Long&gt; {
    private final String name;

    private InvisibleAnonymousClass(String name) {
      this.name = name;
    }

    @Override public Long doInHibernate(Session session) throws HibernateException, SQLException {
      Query query = session.createQuery("select count(*) from Thing where name=:name");
      query.setParameter("name", name);
      return (Long) query.uniqueResult();
    }
  }</pre>
        </code>

        <p class="fragment">Java forces <code>name</code> to be logically <code>final</code> so that it won't matter
          when it is passed to the invisible constructor.
        </p>
      </section>

    </section>
    <section>
      <section>
        <h3>Wizard words</h3>

        <p>More near-synonyms that are (ab)used interchangeably.</p>

        <ul>
          <li class="fragment"><strong>First-class function:</strong> A function that can be stored and passed around as
            a value.
          </li>
          <li class="fragment"><strong>Anonymous function:</strong> A first-class function declared within an
            expression, rather than in
            a definition block where it's given a name.
          </li>
          <li class="fragment"><strong>Lambda (&lambda;):</strong> An operator for declaring an anonymous function.</li>
          <li class="fragment"><strong>Closure:</strong> A first-class function that's equipped with an
            <em>environment</em> (table of
            variables).
          </li>
        </ul>
      </section>
      <section>
        <code class="python"><pre>def square(x):
    return x * x
map(square,  # First-class, but not anonymous
    [1, 2, 3])

map((lambda x: x * x),  # Anonymous
    [1, 2, 3])</pre>
        </code>
      </section>
    </section>
    <section>
      <section>
        <h3>Ground rules</h3>

        <p>Obviously it would defeat the purpose to use Ruby's object-oriented features to implement
          object-oriented
          programming.</p>

        <p class="fragment">But there will be a few exceptions...</p>
      </section>
      <section>
        <h3>Ground rules</h3>

        <p>I get to call the <code>call</code> method on a first-class function.</p>

        <p class="fragment">Ruby's syntax doesn't otherwise make it possible to distinguish between referring to a
          lambda-defined
          function and calling it.</p>
      </section>
      <section>
        <h3>Ground rules</h3>

        <p>I get to use primitive types and basic data structures (<code>Array</code> and <code>Hash</code>), including
          calling their methods.</p>
        <ul>
          <li class="fragment">If we really wanted to, we could implement these from scratch.</li>
          <li class="fragment">Message passing and closures are enough for the basic building blocks.</li>
          <li class="fragment">But, in the interests of time and sanity, we'll use Ruby's nice ones instead.</li>
        </ul>

      </section>
      <section>
        <h3>Ground rules</h3>

        <ul>
          <li>I am using Ruby to make basic classes, not making Ruby classes.
            <ul>
              <li class="fragment">Ruby classes do awesome things.</li>
              <li class="fragment" style="font-size: 80%;">awe·some /ˈôsəm/ <i>adj.</i> &mdash; extremely impressive or
                daunting;
                inspiring great admiration, apprehension, or fear.
              </li>
            </ul>
          </li>
        </ul>

      </section>
      <section>
        <h3>Ground rules</h3>

        <p>And a few more caveats while I'm at it...</p>

        <ul>
          <li class="fragment">There will be mutations.
            <ul>
              <li class="fragment">A purely functional solution is left as an exercise for Haskell enthusiasts.</li>
            </ul>
          </li>
          <li class="fragment">There will be no information hiding.
            <ul>
              <li class="fragment">Python doesn't do it.</li>
            </ul>
          </li>
        </ul>

      </section>
      <section>
        <h3>A few more disclaimers...</h3>

        <p>It will be a little more verbose than native classes.</p>

        <p class="fragment">Pretty syntax is a perk of having the language define classes for you.</p>

      </section>
      <section>
        <h4>My, these are a lot of disclaimers</h4>

        <p>Performance doesn't count.</p>
        <ul>
          <li class="fragment">
            We can't specify details like array storage unless the programming language lets us.
          </li>
          <li class="fragment">&ldquo;Lisp programmers know the value of everything and the cost of nothing.&rdquo;
            <br/>&mdash;<a href="http://pu.inf.uni-tuebingen.de/users/klaeren/epigrams.html">Alan Perlis, <i>Epigrams on
              Programming</i>
            </a></li>
        </ul>

      </section>
      <section>
        <h4>Prices and participation may vary.<br/>Void where prohibited.</h4>

        <p>Also, no type-safety, error-handling, built-in methods, instance-of operator, overloading, or
          constructors.</p>
      </section>
    </section>
    <section>
      <h2>Onto the main event!</h2>
    </section>

    <section class="bigcode"><code class="ruby" data-file="code/step1.rb"></code></section>
    <section class="bigcode"><code class="ruby" data-file="code/step2.rb"></code></section>
    <section class="bigcode"><code class="ruby" data-file="code/step3.rb"></code></section>
    <section class="bigcode"><code class="ruby" data-file="code/step4.rb"></code></section>
    <section class="bigcode"><code class="ruby" data-file="code/step5.rb"></code></section>
    <section class="bigcode"><code class="ruby" data-file="code/wizard_class.rb"></code></section>

    <section>
      <p>View these slides at<br/>
        <a href="http://ryanskonnord.github.io/wizard-class/">http://ryanskonnord.github.io/wizard-class/</a>
      </p>
      <p>Check out the code at<br/>
        <a href="https://github.com/ryanskonnord/wizard-class">https://github.com/ryanskonnord/wizard-class</a>
      </p>
      <p>These slides use <a href="https://github.com/hakimel/reveal.js/">reveal.js</a>.</p>
      <p style="font-size: 50%;">
	<a rel="license" href="http://creativecommons.org/licenses/by/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by/4.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by/4.0/">Creative Commons Attribution 4.0 International License</a>.
      </p>
    </section>

  </div>

</div>

<script src="lib/js/head.min.js"></script>
<script src="js/reveal.js"></script>

<script>

  // Full list of configuration options available at:
  // https://github.com/hakimel/reveal.js#configuration
  Reveal.initialize({
    controls: true,
    progress: true,
    history: true,
    center: true,

    transition: 'slide', // none/fade/slide/convex/concave/zoom

    // Optional reveal.js plugins
    dependencies: [
      {
        src: 'lib/js/classList.js', condition: function () {
        return !document.body.classList;
      }
      },
      {
        src: 'plugin/markdown/marked.js', condition: function () {
        return !!document.querySelector('[data-markdown]');
      }
      },
      {
        src: 'plugin/markdown/markdown.js', condition: function () {
        return !!document.querySelector('[data-markdown]');
      }
      },
      {
        src: 'plugin/highlight/highlight.js', async: true, condition: function () {
        return !!document.querySelector('pre code');
      }, callback: function () {
        hljs.initHighlightingOnLoad();
      }
      },
      {src: 'plugin/zoom-js/zoom.js', async: true},
      {src: 'plugin/notes/notes.js', async: true}
    ]
  });


</script>

</body>
</html>