TITLE: StrangeLoop: Pixie, big-bang, and a Mix Tape
AUTHOR: Eugene Wallingford
DATE: September 29, 2015 4:01 PM
The second day of StrangeLoop was as eventful as the first.
Let me share notes on a few more of the talks that I enjoyed.
In the morning, I learned more about
a small, lightweight version of Lisp at
by Timothy Baldridge, its creator. Why another Lisp,
especially when its creator already knows and enjoys Clojure?
Because he wanted to explore ideas he had come across over
the years. Sometimes, there is no better way to do that than
to create your own language. This is what programmers do.
Pixie uses Clojure-like syntax and semantics, but it diverges
enough from the Clojure spec that he didn't want to be limited
by calling it a variant of Clojure. "Lisp" is a generic term
these days and doesn't carry as much specific baggage.
Baldridge used RPython and the PyPy tool chain to create Pixie,
which has its own virtual machine and its own bytecode format.
It also has garbage collection. (Implementors of RPython-based
languages don't have to write their own GC; they write hints
to a GC generator, which layers the GC code into the generated
C of the interpreter.) Pixie also offers strong interoperation
with C, which makes it possible to speed up even further hot
spots in a program.
For me, the most interesting part of Pixie is
its tracing just-in-time compiler.
A just-in-time compiler, or "JIT", generates target code at run
time, when a specific program provides more information to the
translator than just the language grammar. A tracing JIT
records frequently executed operations, especially in and around
loops, in order to get the information the code generator needs
to produce its output. Tracing JITs are an attractive idea for
implementing a Lisp, in which programs tend to consist of many
small functions. A tracing JIT can dive deep through all those
calls and generate small, tight code.
Rather than give a detailed talk about a specific language,
David Nolen and Michael Bernstein gave
they dubbed "a mix tape to lovers of programming languages".
They presented an incomplete and very personal look at the
history of programming languages, and at each point on the
timeline they offered artists whose songs reflected a similar
development in the music world. Most of the music was out of
the mainstream, where connoisseurs such as Nolen and Bernstein
find and appreciate hidden gems. Some of it sounded odd to a
modern ear, and at one point Bernstein gently assured the
audience, "It's okay to laugh."
The talk even taught me one bit of programming history that I
didn't know before. Apparently, John Backus got his start by
trying to make a hi-fi stereo system for listening to music!
This got him into radios and electronics, and then into
programming computers at the hardware level. Bernstein
quoted Backus as saying, "I figured there had to be a better
way." This adds a new dimension to
something I wrote
on the occasion of Backus's passing. Backus eventually found
himself writing programs to compute missile trajectories on
the IBM 701 mainframe. "Much of my work has come from being
lazy," Backus said, so "I started work on a programming system
to make it easier to write programs." The result was Fortran.
Nolen and Bernstein introduced me to some great old songs, as
well as several new artists. Songs by jazz pianist Cecil
Taylor and jazz guitarist Sonny Sharrock made particular
impressions on me, and I plan to track down more of their work.
Matthias Felleisen combined history and the details of a
specific system in
about big-bang, the most recent development in a 20-year
journey to find ways to integrate programming with mathematical
subjects in a way that helps students learn both topics better.
Over that time, he and the PLT team have created a sequence of
Racket libraries and languages that enable students to begin
with middle-school pre-algebra and progress in smooth steps all
the way up to college-level software engineering. He argued
near the end of his talk that the progression does not stop
there, as extension of big-bang has led to bona fide
CS research into network calculus.
All of this programming is done in the functional style. This
is an essential constraint if we wish to help students learn
and so real math. Felleisen declared boldly "I don't care
about programming per se" when it comes to programming
in the schools. Even students who never write another program
again should have learned something valuable in the content area.
The meat of the talk demonstrated how big-bang makes it possible
for students to create interactive, graphical programs using
nothing but algebraic expressions. I can't really do justice to
Matthias's story or storytelling here, so you should probably
watch the video. I can say, though, that the story he tells
here meshes neatly with
The Racket Way
as part of a holistic vision of computing unlike most anything
you will find in the computing world. It's impressive both in
the scope of its goals and in the scope of the tools it has
More notes on StrangeLoop soon.
PHOTO. I took both photos above from my seats in the audience
at StrangeLoop. Please pardon my unsteady hand.