
Dylan: A New Language Is Blowin' in the Wind (1992) - e12e
https://www.schneier.com/essays/archives/1992/09/dylan_a_new_language.html
======
ekidd
Ah, Dylan was a ton of fun.

First, some personal background: When I was an intern at Harlequin, I was one
of the first users of Harlequin Dylan. Later, when CMU stopped work on Gwydion
Dylan, I helped start an open source project to maintain it. And when
Harlequin wanted to start open sourcing their Dylan (which later became
[https://opendylan.org/](https://opendylan.org/) ), I met with them to help
hammer out licensing details. Harlequin released a _lot_ of cool code.

What was cool about Dylan? Well, it was a basically a relative of Common Lisp,
but with an infix syntax, but it had been simplified to improve code
performance. It was a more ambitious language than Java, with full closures,
basic macros, and generic functions. Dylan had static typing if you wanted it,
or you could leave code untyped. (Unfortunately, collection and function types
were fairly weak due to the lack of standardized generic types.)

In the end, Apple's abandonment of Dylan and the rise of Java united to make
Dylan irrelevant. But it was a fun language, and I had a lot of fun hacking in
it. I think that the closest popular language at the moment, design-wise, is
probably Julia.

I still remember one 20-hour day that where a friend and I set up tower
computers in a cozy basement room at Dartmouth, and I eventually convinced the
Gwydian FFI tool to parse 10,000 lines of Linux headers.

------
dasmoth
The implementation was open-sourced and had a fair amount of work put into
modernising it. Things seem to have gone quiet the last couple of years, but
it's out there if anyone wants to try it:

[https://opendylan.org/](https://opendylan.org/)

~~~
lispm
This is not Apple's Dylan implementation, but Harlequin's. Apple's
implementation has not been published, AFAIK.

~~~
dasmoth
Thanks. I've never really been clear on the relationship between Harlequin and
Apple on Dylan stuff -- were they totally separate impls?

~~~
lispm
Yes, completely different.

Apple's Dylan implementation was written in Macintosh Common Lisp.

Harlequin started with a LispWorks-based implementation and then had an all-
in-Dylan implementation.

This is the old Common Lisp / LispWorks implementation of Dylan from
Harlequin:

[https://github.com/dylan-
lang/opendylan/tree/5f9225d246d771c...](https://github.com/dylan-
lang/opendylan/tree/5f9225d246d771cfaa2fa4f255a4447bff6991b8/old/Sources/emulator)

------
dasmoth
David Moon designed a post-Dylan language called PLOT:

[http://users.rcn.com/david-moon/PLOT/](http://users.rcn.com/david-moon/PLOT/)

(Not implemented as far as I know)

~~~
mikelevins
I think you're right. Moon and I exchanged a little mail about it a few years
ago. He wrote to tell me he liked Bard, my Dylan-influenced Lisp, and I think
he said PLOT wasn't implemented.

Interestingly, he also said he had a solution to class linearization that was
superior to C3, but that he couldn't remember the details. I asked for more
information, but he said that if he still had the notes they were in the attic
or something.

I'd still like to see his solution.

~~~
dasmoth
Thanks for pointing out Bard, I'll take a look!

~~~
mikelevins
It's dormant right now. I've been busy with other things.

I do plan to start work on an updated version soon. Feel free to mail me at
mikel at evins dot net if you want to chat about Bard.

------
coldtea
Ah, if only Dylan and Smalltalk had survived the 90s.

~~~
protomyth
I'm pretty sure the Pharo folks would say Smalltalk isn't dead yet.
[http://pharo.org/](http://pharo.org/)
[https://www.pharocloud.com/](https://www.pharocloud.com/)

~~~
coldtea
Yes they could say it, but popularity and support wise it wouldn't mean much.

Survived = at least at the same level of use as Ruby, Python, PHP, etc -- or
at least Go and Rust.

~~~
agumonkey
Unfair to compare to PHP and Ruby who blossomed because of the web.

Go and Rust are recent and massively backed.

I did a Pharo MOOC last year, ST is far from dead, it's "streets ahead" in
many department its not even funny.

~~~
int_19h
Fairness is inherently out of scope in such comparisons.

~~~
agumonkey
I just changed that rule.

------
st3fan
Too bad Dylan never made it to the Newton. I’m actually not sure that was ever
the intention. Dylan was pretty heavy weight?

~~~
osteele
That was definitely the intention. It was intended as a systems and
application programming language for the Newton.

The original Apple implementation compiled to native ARM code. The runtime was
intended to be competitive with C, but by the time we approached that target,
large parts of the toolbox had already been written in C, and Walter Smith had
created NewtonScript as a scripting language that worked as an alternative for
non-performance-critical code. At that point the Cambridge team re-targetted
the implementation to build Macintosh applications, but that wasn't a
sufficiently compelling (to Apple management) use, and we had lost our
executive sponsor when the director of the Apple Cambridge lab was promoted to
a position in Cupertino.

For those curious about Dylan's history, the Wikipedia page
[https://en.wikipedia.org/wiki/History_of_the_Dylan_programmi...](https://en.wikipedia.org/wiki/History_of_the_Dylan_programming_language)
looks correct.

(I'm the “Oliver Steele” mentioned on that page. I went to Apple Dylan from
Skia – later released as Quickdraw GX – _another_ technology that missed the
Newton boat.)

~~~
mikelevins
I'm the Mikel Evins mentioned on that page.

Everything you say is right. Some details look maybe a little different when
viewed from the Newton team in Cupertino.

Yes, as the Dylan runtime got better, the Newton team wrote an OS in C++ with
NewtonScript for scripting. There's more back story there, though.

Before any of that work started, an earlier iteration of the OS had already
been written in the early Dylan, back when it was still called Ralph. There
seemed to be some level of discontent in a few different quarters with that
OS. Different people expressed different criticisms (that I heard). Different
people assigned blame for their dissatisfactions differently.

It was all pretty good-natured, from what I remember.

But then John Scully told Larry Tesler: Let There Be an OS Written in C++. And
there was. There is various gossip about exactly how that came to pass, but it
did come to pass.

Larry asked me and a couple of other people to see what we could do with
Dylan. We took that ball and ran with it--maybe too far. Like maybe Larry
wanted us to run it down to the end zone and instead we ran it across the
border and into Patagonia somewhere. We, the five of us or so, wrote a whole
OS in Dylan, essentially competing with the 60 or so people working on
Scully's mandated C++ OS.

I don't know why we did it exactly, except that we could, and it was really
interesting. More to the point, I don't know why Apple management let us keep
going with it so long. Morbid curiosity maybe? It did work pretty well, and I
think there were some pretty interesting ideas in it.

From a business point of view, though, it was silly. Obviously Apple was never
going to ship 2 Newton OSes. Equally obviously, it wasn't going to choose to
develop our weirdo Lisp OS instead of Capps' C++ OS that was developed by
almost the whole Newton team in response to an order from on high.

The period you describe, when Dylan was getting pretty good and the Capps OS
had a lot of features and NewtonScript was pretty well working was well after
the inflection point where the main group started working on the C++ OS. Our
smaller team started on the second Dylan OS about the same time the other team
started on their OS, and we made good (though pointless) headway. We used the
same microkernel they did, and the same graphics infrastructure. Everything
else in ours was written in Dylan. Dylan worked great.

In fact, that version of Dylan remains my favorite general-purpose programming
language ever. I pretty much lost interest in Dylan when it stopped looking
and working like a Lisp, but I've never liked anything else as much for day-
to-day programming--not even Common Lisp, which is my go-to nowadays.

~~~
wrs
Creator of NewtonScript here… Hi Mikel! I'm glad to hear you say it was good-
natured, because I loved Dylan—having been the Newton team's Cambridge liaison
and Ralph cheerleader since the Cambridge team joined Apple. I was just head-
down trying to build a small language that had at least _some_ of the goodness
of Dylan so we didn't ship something that was just a C++ app in a box!

~~~
mikelevins
Hey, Walter! Lovely to hear from you.

I know you loved Dylan, and I know what you were up to with NewtonScript.

I did a little work in NewtonScript for the shipping Newton before I migrated
to NeXT. It worked. Or it would have, if Newton had been a better fit for the
market of the time.

The Cambridge team (or big chunks of it) later became Clozure Associates, Lisp
consultants and maintainers of Clozure Common Lisp. I've worked for them off
and on over the years on some interesting stuff.

------
thomasjudge
"C++ is the COBOL of the 90's" \- Jeff Alger

~~~
int_19h
I'm pretty sure that Java is the COBOL of 90s (and 00s, for that matter).

