Truth IS stranger than fiction

An amazing look back at Java's early days, by Chuck McManis on HN:

---

Tcl was the 'language to beat' amongst the new language products. Self was the 'language like no other' (or a totally new way to express what you wanted to a computer). Java was the 'language that re-used code'. C++ was kind of a joke (remember this was the late 80's, early 90's) since it took a perfectly acceptable language, C, and made writing code harder, more error prone, and less likely to produce correct code (all true at the time).

Tcl was a language of rapid expression and Java was a language which was safer, in part, because it enforced a certain level of correctness (type safety, no pointer arithmetic, Etc.).

Tcl had a "huge" installed base of developers, Java had zero developers and hoped to have 10 or 20K eventually.

Bert Sutherland (the guy running Sun Labs and Ivan's brother) got everyone in a room and said "We're going to have a 'language' day, and each of you gets to present why you think your language should exist." the issue was of course that Sun had only so much budget and we had no business reason for developing any new languages.
Surprisingly to some, Tcl 'won' that evaluation. Self was going to continue because Bill could self fund it if he wanted to, and Tcl had the developer base and momentum. The decision was taken to scrap the remains of the Java team (called the Live Oak project at the time) at the end of the Fiscal Year (June 30th, 1995). We were all set to be 're-deployed' which was Sun code for 'find a new job inside of Sun or we'll lay you off.'

What happened next was unexpected. James Gosling, with Kim Polese's help, had convinced the lawyers to allow us to release the source code for 'free' (very un-Sun like) so that we could at least point at something we had done on our resumes. The requirement was that we have a trademarkable name for it (which I believe was, in part, to prevent Apple or Microsoft from re-publishing it as their own thing). We dropped Alpha 1.1 (we had secretly released Alpha 1.0 in February) on March 23rd. Kim sent out a press release to some folks. (not sure if she used PR Newswire or not) The Mercury News put it on the front page, they got a quote from Marc Andresson over at Netscape that it was cool. When I went to the WWW conference 2.0 (as in second conference :-) in Darmstadt Germany two weeks later, everyone wanted to talk about it. I manually downloaded and installed it on all the Sparcstation 20's that the sales office had brought to the conference and gave a quick set of talking points to the sales guys. When I got back there was a storm because folks like Ed Zander were demanding to know why they hadn't been briefed before we announced it, Phil Sampire(sp?) was complaining that people kept calling the sales office to get their sales droid to come out and talk about it and they had no marketing material and no prep. May press conference was already queued up as the SparcStation 20 / Firewall-One launch event, the SS20 got the boot and they replaced it with the Java 'launch'. I spent a crazy couple of weeks creating a completely Java home page for Sun (had I known it was a portent of all flash sites to come I might have shot myself right then and there :-)

Everyone 'forgot' about how they were going to flush the team and instead everyone came out of the woodwork to claim they had supported it all along, SunSoft, SunLabs, and Sun Interactive (which had the only financial success with it at the time, competing against the Time Warner VOD bids). An entirely new 'planet' was born, called JavaSoft and the rest is history.

What Java gave Sun at that point in time was a credible threat against Microsoft. The threat was that the new desktop was the browser, and the way you coded for the browser was Java. Tcl didn't play in that space, and to their credit I don't think the Tcl folks were willing to go there just to ride the buzz.

Java's wake grew to eclipse the other language efforts and Sun never looked back.

Duke's Law

Raoul Duke:

As soon as somebody brings in a reference to xah lee, somebody else has to call somebody a Nazi, and then somebody else has to invoke the spirit of john harrop when he was an ocaml instead of F# bigot, etc. etc.

Syntax puns considered harmful (well, not really)

Schemers use the word "syntax" to mean at least two (and maybe even three) different things:

• in DEFINE-SYNTAX and LET-SYNTAX, syntax means macro expander
• in SYNTAX and QUASISYNTAX, syntax means code
• in BEGIN-FOR-SYNTAX, syntax means compile-time (although it's debatable whether this use of syntax is really different from the first one)

There is a certain elegance in that, but in the end it's also a bit silly.

And it's problematic, as the (awesome) paper Languages as Libraries shows: because LET-SYNTAX is already taken to mean "locally bind a macro expander", they have to use WITH-SYNTAX to mean "locally bind a piece of code".

Don't diss Java - Be Happy

On the occasion of Gosling joining Google, it's Java diss time again. But most Java criticism doesn't take its raison d'être into account:

We were after the C++ programmers. We managed to drag a lot of them about halfway to Lisp. Aren't you happy? — Guy Steele

Java has many faults. But most of them are there by design. That's not something many language designers can claim.

Java was a Trojan Horse, designed to slip in a modicum of dynamic features without C++'ers getting suspicious.

That whole dynamic-language-in-the-mainstream thing may have never happened without Java.

Aren't you happy?

Computational Trinitarianism

Given that software is so utterly confusing, it's often helpful to bring in metaphors from other areas, Christianity in this case: The Holy Trinity from Bob Harper's excellent Existential Type:

The Christian doctrine of trinitarianism states that there is one God that is manifest in three persons, the Father, the Son, and the Holy Spirit, who together form the Holy Trinity. The doctrine of computational trinitarianism holds that computation manifests itself in three forms: proofs of propositions, programs of a type, and mappings between structures. These three aspects give rise to three sects of worship: Logic, which gives primacy to proofs and propositions; Languages, which gives primacy to programs and types; Categories, which gives primacy to mappings and structures. The central dogma of computational trinitarianism holds that Logic, Languages, and Categories are but three manifestations of one divine notion of computation. There is no preferred route to enlightenment: each aspect provides insights that comprise the experience of computation in our lives.

OOP, again and again and again

Nothing gets LtU's juices flowing like a good old OOP discussion. It starts with a harmless "OO is anti-modular? Really?" and runs into the right margin very quickly. It's worth a read.

In that thread there's also a quote describing OOP that's very close to my POV, by Jonathan Aldrich:

building dynamic dispatch into the language ... is the one thing that separates languages commonly considered "OO" from those that are not

Previously: Why are objects so unintuitive.

That explains it

Kent Pitman:

I certainly sat in lots of Scheme design meetings where I pushed for obvious things like branch cuts, error handling, and other "useful" things and was told that such things would ... make the language "too useful" [thus meaning too many people would flock to it and it would be the end of the designers' ability to do the things to the language that _they_ wanted to do].

Seriously though, this shows that the forces behind Scheme are far from obvious.

Understanding Hygiene (part 2) -- SRFI 72

My critically acclaimed Understanding Hygiene (part 1) contains the absolute baseline necessary for understanding hygienic macros.

This post is about my understanding of André van Tonder's SRFI 72 - a specific way of implementing hygiene, which differs from more widely used hygienic systems such as the venerable syntax-case.

It must be said that hygiene is still an area of active research. There be dragons. Nevertheless, van Tonder is quite confident of his design, going so far as calling it "improved hygiene". David Herman, who wrote the bookdissertation on the theory of hygienic macros is skeptical. Anton van Straaten makes some mediatory points. Matthew Flatt raises even more mind-bending questions.

That said, for a hygiene noob like me, SRFI 72 seems to be an elegant and workable design. I wrote a half-assed Lisp->C compiler that contains a SRFI 72 inspired macro system (here's a test from SRFI 72 in my Lisp that works -- phew) and the experience was quite pleasurable. Of the couple thousand lines of C in the system, only a couple dozen or so deal with hygiene.

Basically, what SRFI 72 says is this: when you create a piece of code using the code constructors syntax or quasisyntax, e.g.

(syntax (let ((x 1)) (foo x)))

the identifiers in there (let, x, foo) get a fresh hygiene context (or "color"). Thus they won't conflict with identifiers of another color -- such as those created by somebody else (e.g. another macro, or the user's source). That was the easy part.

Additionally, SRFI 72 makes such pieces of code obey a discipline that is similar to lexical scoping. That is the meaning of 72's money quote that van Tonder repeats multiple times, in the hope of hammering his point home:

the evaluation of any nested, unquoted syntax or quasisyntax forms counts as part of the evaluation of an enclosing quasisyntax.

Say we have some piece of silly code, like:

(quasisyntax (bla bla bla ,(some-unquoted-stuff (lambda () (quasisyntax (bla bla bla))))))

The outer quasisyntax constructs/quotes the piece of code. Then the "," unquotes and we call some contrived function that happens to take a lambda as argument. Then, inside the lambda there's another quasisyntax, so we're quoted again. The contrived unquoted stuff and the lambda don't matter. What matters is that there's an inner quasisyntax lexically embedded in the outer quasisyntax.

Now, SRFI 72's money quote tells us that the inner quasisyntax's bla's have the same color as the outer quasisyntax's bla's. Why? Because the inner quasisyntax is lexically nested in the outer quasisyntax, and like a lexical variable binding, the outer quasisyntax's color is "inherited" down to the inner quasisyntax.

This took me a looooooooooooooooooong while to figure out, and I hope that this post will help those trying to understand SRFI 72.

Questions?

Language design criticism = art criticism (?)

A comment by Sean McDirmid on LtU is spinning off into a nice PL design discussion:

We should only critique designs like we critique art, I like this and I don't like that, made from the perspective of another person's tastes. C++ is an example of a language that has a controversial rather than poor design, some people find it ugly while others find it beautiful. A good design is simply a language designed by a good designer, and it might not suit your tastes but you should appreciate it for what it is, right?

I got into some arguments recently over Scala. That I was critical of Scala and compared it to C++ led someone to think I was a Scala hater, while nothing could be farther from the truth. People tend to get very emotional about their languages (or paradigm) of choice. A good discussion involves acknowledging our biases and being objective about our and others' opinions.