TITLE: Fighting Entropy in Class
AUTHOR: Eugene Wallingford
DATE: March 29, 2023  2:39 PM
DESC: 
-----
BODY:
 On Friday, I wrote a note to myself about updating an upcoming class
 session:

<blockquote><em>
 Clean out the old cruft.  Simplify, simplify, simplify!  I want
 students to grok the idea and the implementation.  All that Lisp
 and Scheme history is fun for me, but it gets in the students' way.
</em></blockquote>

 This is part of an ongoing battle for me.  Intellectually, I know
 to design class sessions and activities focused on where students
 are and what they need to do in order to learn.  Yet it continually
 happens that I strike upon a good approach for a session, and then
 over the years I stick a little extra in here and there; within a
 few iterations I have a big ball of mud.  Or I fool myself that
 some bit of history that I find fascinating is somehow essential
 for students to learn about, too, so I keep it in a session.  Over
 the years, the history grows more and more distant; the needs of
 the session evolve, but I keep the old trivia in there, filling up
 time and distracting my students.

 It's hard.

 The specific case in question here is a session in my programming
 languages course called Creating New Syntax.  The session has the
 modest goal of introducing students to the idea of using macros
 and other tools to define new syntactic constructs in a language.
 My students come into the course with no Racket or Lisp experience,
 and only a few have enough experience with C/C++ that they may have
 seen its textual macros.  My plan for this session is to expose
 them to a few ideas and then to demonstrate one of Racket's
 wonderful facilities for creating new syntax.  Given the other
 demands of the course, we don't have time to go deep, only to get
 a taste.

 [In my dreams, I sometimes imagine reorienting this part of my
 course around something like Matthew Butterick's
 <a href="https://beautifulracket.com/">
    Beautiful Racket</a>...
 Maybe someday.]

 Looking at my notes for this session on Friday, I remembered just
 how overloaded and distracting the session has become.  Over the
 years, I've pared away the extraneous material on macros in Lisp
 and C, but now it has evolved to include too many ideas and
 incomplete examples of macros in Racket.  Each by itself might
 make for a useful part of the story.  Together, they pull
 attention here and there without ever closing the deal.

 I feel like the story I've been telling is getting in the way of
 the one or two key ideas about this topic I want students to walk
 away from the course with.  It's time to clean the session up --
 to make some major changes -- and tell a more effective story.

 The specific idea I seized upon on Friday is an old idea I've had
 in mind for a while but never tried: adding a Python-like for-loop:
<pre>
    (for i in lst: (sqrt i))
</pre>

 [Yes, I know that Racket already has a fine set of for-loops!
 This is just a simple form that lets my students connect their
 fondness for Python with the topic at hand.]

 This functional loop is equivalent to a Racket <tt>map</tt>
 expression:
<pre>
    (map (lambda (i)
           (sqrt i))
	 lst)
</pre>

 We can write a simple list-to-list translator that converts the
 loop to an equivalent map:
<pre>
    (define for-to-map
      (lambda (for-exp)
        (let ((var (second for-exp))
              (lst (fourth for-exp))
              (exp (sixth for-exp)))
          (list 'map
                (list 'lambda (list var) exp)
                lst))))
</pre>

 This code handles only the surface syntax of the new form.  To
 add it to the language, we'd have to recursively translate the
 form.  But this simple function alone demonstrates the idea of
 translational semantics, and shows just how easy it can be to
 convert a simple syntactic abstraction into an equivalent core
 form.

 Racket, of course, gives us better options!  Here is the same
 transformer using the <tt>syntax-rules</tt> operator:
<pre>
    (define-syntax for-p
      (syntax-rules (in &colon;)
        ( (for-p var in lst : exp)
            (map (lambda (var) exp) lst) )  ))
</pre>

 So easy.  So powerful.  So clear.  And this does more than
 translate surface syntax in the form of a Racket list; it
 enables the Racket language processor to expand the expression
 in place and execute the result:
<pre>
    &gt; (for-p i in (range 0 10):
        (sqrt i))
    '(0
      1
      1.4142135623730951
      ...
      2.8284271247461903
      3)
</pre>

 This small example demonstrates the key idea about macros and
 syntax transformers that I want students to take from this
 session.  I plan to open the session with <tt>for-p</tt>, and
 then move on to <tt>range-case</tt>, a more complex operator
 that demonstrates more of <tt>syntax-rules</tt>'s range and
 power.

 This sets me up for a fun session in a little over a week.  I'm
 excited to see how it plays with students.  Renewed simplicity
 and focus should help.
-----