I came across a version of Dijkstra’s “Goto Considered Harmful” annotated by David Tribble. A lot has changed since then; the annotated version is perfect for acquiring the right context to read the paper.

There was a particular line by the annotator that continues to amuse me:

Dijkstra seems to imply that iterative looping (inductive) statements are intellectually harder to grasp than recursion, which is the kind of thing only a mathematician would say.

Among the ways you can bisect computer science, is whether this statement insults or compliments.

I’ve got a fairly terrible draft of a quickref sheet for Common Lisp. This should be enough to recall the most common/needed commands, but it’s fairly terrible at this point. That said, it might be useful for someone out there:

Wait what. Python compiles? That is correct. CPython and PyPy (the implementations worth caring about currently) are in fact creating a code object from the string you pass to exec or eval before executing it. And that’s just one of the things many people don’t know about the exec statement.

It doesn’t always have to be about theory, nor should it be. I might recommend this article for programmers already versed in Python, to read side by side or leading up to SICP’s “Metalinguistic Abstractions” chapter.

I bought an Amazon Kindle 3G back in October. So far I’ve mostly been reading research papers on it (that 3rd gen eInk really is amazing), occasionally proggit.

I applied for SDK access, but heard nothing back. So instead, I’m using the built in “experimental” web browser. It has canvas support, so I’m golden.

As you might have noticed, I couldn’t resist the urge to design a vector font for the task; please be gentle, I know the font leaves a lot to be desired, it’s a work in progress. The Kindle browser didn’t seem to have font support anyway, while public domain, I didn’t particularly enjoy the Hershey fonts. The Hershey fonts are nice, but they’re unsuitable for programming.

[Async methods] allow you to compose asynchronous stuff using normal flow of control and using all of the statements that you know already.

Pretty sweet. The first (longer) portion of the presentation is on the new asynchronous programming features for C# and VB. A hidden gem at the end (starting at timecode 50:40) is the “Compiler as a Service” status report. They’re experimenting with providing compiler front end, back end, and intermediate transformations as a run-time library.

It’s curious that there was no mention of the async transformations (first section) during his discussion of general purpose syntax transformations (second section). It would be interesting to see whether the “Compiler as a Service” libraries provide sufficient support as to be able to extend C# with things like ‘iterator syntax’ or ‘async methods’, without having to wait for a new compiler.

(A nod of course to Lisp’s macros, Scheme’s continuations, and Haskell’s use of monads; for defining new control flow primitives)

Eric Lippert of Fabulous Adventures In Coding has posted a series on CPS tranformation and different control flow abstractions. Good stuff — recommended reading for translating the crazy stuff I talk about into ‘normal’ code.