PurelyFunctional.tv Newsletter 207: Guy Steele, Jr.

Free Beginner Workshop

From OO to Clojure Workshop!

Watch my free workshop to help you learn Clojure faster and shift your paradigm to functional.


Issue 207 - January 09, 2017


Hi Clojurists,

I've long been a fan of Guy Steele. I was first introduced to him because he was the author of Common Lisp, The Language. But then I found that he also co-invented Scheme. This blew my Lisp-2 mind. How could he work on Lisp-2 and Lisp-1? Then I found out he wrote the Java spec and was totally baffled. Java? He was supposed to be a Lisper! But it gets worse. He was working on Fortran!

The whole experience of learning about Guy Steele shook me deeply. I realized I was being silly. I believed there was One True Language that all languages aspired and competed to be. But this is not true. And Guy Steele embodies the view that you can be fair-minded, that features can be borrowed, that all languages have warts, and that we're still learning how best to design languages.

Please enjoy this selection of Guy Steele's work. He was truly important in the history of programming languages.

Rock on!
Eric Normand <eric@lispcast.com>

PS Want to get this in your email? Subscribe!


Growing a Language YouTube

What a great presentation. I don't want to spoil anything about this. But you will come away with a new understanding of how verbose our current style of programming is and why it is that we have to define everything ourselves. Further, he presents a veritable manifesto of extensibility of languages with a potential solution to the Worse-Is-Better paradox.

A transcript is available.


Organizing Functional Code for Parallel Execution Vimeo

Forget about Monads. We absolutely need to start thinking about Monoids. And not just any monoids. They need to split a problem evenly, not first-and-rest as we typically do with sequences in most functional languages. This talk directly inspired Clojure's reducers library.


The Evolution of Lisp InfoQ

An awkward re-enactment of a talk the speakers gave 25 years before. It's an interesting talk, but a re-enactment? It's a little stilted. However, if you're looking for a history of Lisp as it was in 1993, it's got great information.

There was a paper writter by the presenters on the same topic.


Fortress Features and Lessons Learned YouTube

Guy Steele led a team of programming language researchers to develop a language called "Fortress". It was an amalgam of 20 far-out ideas, including mathy unicode syntax, extreme extensibility, and automated parallelism. The project was eventually defunded. But he shares some of the things they learned with the Julia community.


Four Solutions to a Trivial Problem YouTube

Guy Steele presents four different solutions to a single problem. The first solution is a purely sequential solution programmed with a for loop. He then shows how a "build-and-conquer" approach is much better for automated concurrency. His argument is that we will soon have to change the patterns we use for solving problems because they are inherently sequential. As things need to become more parallel, we will need the language to automatically find opportunities (either at compile-time or runtime) to run things in parallel.


Debunking the "Expensive Procedure Call" Myth PDF

or, Procedure Call Implementations Considered Harmful

or, LAMBDA: The Ultimate GOTO

This paper is so important in the history of compiler design. Before this paper, it was commonly thought that function calls were very expensive and should be minimized. Steele showed that they could be, in many important cases, be compiled into a single GOTO. This makes function calls strictly better than GOTO and cheap enough to do all the time. Thank this paper next time you write a one-line function.


LAMBDA: The Ultimate Declarative PDF

Wow! A super-important paper in the history of Lisp and programming language implementation in general. Many compiler techniques that are in use in languages like JavaScript were first presented here. This paper follows and attempts to correct the previous paper LAMBDA: The Ultimate GOTO. The correction was that it isn't Lambdas that are GOTOs, but function invocation.

This paper brings a different perspective to functions. It shows that they can be seen as a naming operation within an environment. The paper takes this expression to logical conclusions, which lead to new compiler techniques.


The Art of the Interpreter PDF

This paper shows how an interpreter can be used to quickly prototype new language features. They go through a small portion of the history of the features of Lisp.


Guy Steele: Programmer Profile

I've put together a larger page about Guy Steele. It includes a large selection of talks and papers with my comments.