History of the Dylan programming language

From Wikipedia, the free encyclopedia

Dylan programming language history describes milestones as well as watersheds in the history of the Dylan programming language.

Contents 1 Timeline 2 Historical Milestones 2.1 The roots of the programming language Dylan 2.2 The roots of changing the syntax from lisp way to an infix one 2.3 End of Dylan as commercial product 2.3.1 Project Death at Apple in 1995 2.3.2 The Death at Harlequin and Functional Objects 2.4 Dylan's revival as Open Source Project 2.4.1 First: The CMU's Gwydion Project became Open Source 2.4.2 Second: The Harlequin / Functional Object Project became Open Source 3 External links

[edit] Timeline

April 1992: The first Dylan Language Specification is released. It proposes a Lisp-like syntax for the new language.

Sep. 1992: Andrew L. M. Shalit, a member of the Apple Cambridge Research Laboratory, announces the creation of an electronic mailing list for discussion of the Dylan programming language.

Jan. 1993: Jonathan Bachrach writes to comp.lang.dylan]: "I am trying to start a Dylan programming revolution at my work." Scott Fahlman, the Dylan project leader at Carnegie Mellon replies: "The best strategy is probably to wait until Dylan is real (and maybe help it to become real)..." ( Quote from comp.lang.dylan ).

April 1993: Release of the first Dylan FAQ.

Sep. 1993: Bachrach presents a High-Performance Dylan Implementation at the International Computer Music Conference at Waseda University.

Sep. 1993: The first public domain Dylan compiler, written by Bachrach, is unveiled at MacWorld. "[H]e built the first implementation as a set of macros for the Python LISP compiler. In the following months, the elements of his macro set were transformed from macros into LISP, and later into Dylan itself." Quote from MacTech

June 1994: Robert Stockton announces an online browsable version of the new Dylan Interim Reference Manual. At Carnegie Mellon, the Dylan project is called the Gwydion Project. Headed by Fahlmann, it includes many of the same people responsible for CMU Common Lisp.

May 1994: MacTech reports on the SFA meeting Atlanta: "Ike Nassi used to run Apple's Advanced Technology group in Cambridge, Massachusetts, where Dylan originated. Now vice president of Apple's Development Products group, Nassi has made one of his goals the establishment of OODLs (object oriented dynamic languages) as a mainstream programming paradigm. He also stated that Dylan was "in use at Apple today". Andrew Shalitt stated that Dylan has moved into product development. It was hinted that third parties were at work on development environments; nothing specific was said about what such an environment might look like. Dylan received a new infix syntax. Syntax surveys were distributed at the conference to help the language designers finalize their decisions. Andrew's presentation included a number of examples of Dylan code." Quoted from [ http://www.mactech.com/articles/frameworks/8_3/1994_Conference_Report.html MacTech].

Oct. 1995: It is announced that the Cambridge Dylan project will be terminated and its staff laid off.

Dec. 1995: Russ Daniels, the interim Apple engineering manager for Dylan in Cupertino, announces that Digitool, Inc. will port Apple's Dylan Technology Release to PowerPC Macintosh Common Lisp (MCL).

Jan. 1996: Apple shuts down the Cambridge R&D Group permanently. The site cambridge.apple.com disappears.

Aug. 1996: Apple ships PowerPC-native Dylan (ported by Digitool). Quoted from Digitool

Sep. 1998: Fahlman announces that Dylan has been turned over to Harlequin: "In fact, if not in theory, Dylan is now completely in Harlequin's hands. Apple is no longer involved with Dylan, nor is the CMU Gwydion project. Some dedicated volunteers are working to improve the Gwydion version, and there may still be a couple of one-person implementation efforts, but whatever Harlequin does will define what Dylan is. Harlequin wants Dylan to succeed, and presumably they will do the things that they think are most important for Dylan's acceptance." ( Scott Fahlmann on comp.lang.dylan ).

Oct. 1998: Harlequin Dylan 1.1 was announced at OOPSLA 1998 in Vancouver.

1998/1999: A group of volunteers picks up CMU's Gwydion sources. The website GwydionDylan becomes a base for Dylan enthusiasts.

March 1999: Service Pack 1 for Harlequin Dylan 1.2.

Sep. 1999: Global Graphics, the new owner of Harlequin, Inc., announces the divestiture of Harlequin Dylan and the transfer of the product to Functional Objects.

July 2000: Bachrach announces the availability of Functional Developer 2.0.1 and 2.0 service pack 1.

2003: Functional Objects makes Dylan's code open source software.

[edit] Historical Milestones

[edit] The roots of the programming language Dylan

Dylan was created by the same group at Apple that was responsible for Macintosh Common Lisp. The first implementation had a Lisp-like syntax.

Dylan began with the acquisition of Coral Software, which became ATG East. Coral was marketing Macintosh Common Lisp, and Apple asked them to continue to support MCL and simultaneously develop a new dynamic language with all the programmer power and convenience of Lisp and Smalltalk but with the performance required for production applications

Quoted from MacTech Vol 7 No. 1

In the late 80’s, Apple’s Advanced Technology Group (ATG) saddled themselves with the task of creating a new language, one that would combine the best qualities of dynamic languages like Smalltalk™ and Lisp, with those of static languages like C++. Recognizing that a language definition alone wasn’t sufficient to meet the challenges of developing the next ever-more complex generation of software, ATG further committed the Dylan team (now a part of the Developer Products Group) to developing an attendant development environment that would enable the rapid prototyping and construction of real-world applications

Quoted from MacTech Vol 11 No. 8

The two non-Apple collaborators were CMU Gwydion and Harlequin.

"I think our general impression was that our influence at CMU was limited to being able to participate in meetings and email discussions where we could try to convince the Apple people to see things our way. There was actually a great deal of consensus about many issues, mainly because the designers were primarily from the Common Lisp community, and saw similar strengths and failings of Common Lisp."

Rob MacLachlan, former member of CMU's Dylan project Gwydion.

[edit] The roots of changing the syntax from lisp way to an infix one

The developers at the Cambridge lab and CMU thought they'd get better reception from the C/C++ community out there if they changed the syntax to make it look more like these languages.

Rob MacLachlan, at Carnegie Mellon during the Dylan project, from comp.lang.dylan:

"In a way, the most remarkable realignment was the decision to ditch the Lisp syntax. This happened after Gwydion was participating in the design effort. We advocated the infix syntax and ditching the lisp/prefix syntax. As I recall, we didn't really expect anyone to listen, but that was exactly what happened. In that case, we may have shifted the balance of power internal to Apple on this issue."

Bruce Hoult replied:

"Which interestingly enough is the reverse of Lisp itself, where Johm McCarthy originally intended S- expressions to be just a temporary form until the real syntax was developed/implemented."

Oliver Steele in a ll1-discuss:

"Mike Kahl, who designed the infix syntax (and implemented the parser and indenter for it), was trying to make it look like Pascal. At the time (1991?), that probably looked like a better bet than it does today in the world of languages that have mostly converged on the use of punctuation marks as punctuation.

I had actually implemented a more C-like (that is, braces) syntax for Dylan, but dropped it when we hired Mike in order to work on the IDE."

[edit] End of Dylan as commercial product

[edit] Project Death at Apple in 1995

Raffael Cavallaro once provided some insights:

The Apple Dylan project died in early '95 (if memory serves - I was a seed site for Apple Dylan). The Dylan team were under a lot of pressure to get a working release out the door when two things sort of took them by surprise:

1. Apple started to become less profitable because of the Wintel juggernaut. With Apple no longer so profitable, the Apple suits started to look for research projects to axe. Those that didn't seem likely to ship a profitable product in the near future were at the top of the list. Apple Dylan at the time was still not ready for release - it compiled pretty slowly... especially compared to CodeWarrior C/C++, since it hadn't yet been optimized. Apple managers were talking about rewriting it in C++ to make it run faster (not realizing that Common Lisp can be optimized to run as quickly as C/C++).

2. Apple was making the transition to PowerPC, and Apple Dylan still only ran on 68k machines, and only compiled to 68k binaries. So, it was looking like it would be at least another year, maybe two before there was a usable PowerPC product, so the project was cancelled.

Apple execs killed the Dylan project... because nobody could show them a release-quality product when they started swinging the meat axes.

Oliver Steele:

I'm convinced that Apple Dylan sank because the development team tried to cram all our favorite features into it (mine had to do with the IDE).

From Mike Lockwood, a former member of the Apple Cambridge Labs (originally published on apple.computerhistory.org):

I started my career at Apple in the developer tools group in Cupertino. But after a couple of years I decided to move east, and transferred to the Cambridge office to work on the Dylan project. In April 1995, we were notified that the project would be cancelled and we would all be laid off. But we were not to be laid off immediately. Apple wanted us to stay for 6 months so Dylan could be released as an experimental "technology release". This was apparently done to avoid embarrassment at WWDC the following month. Dylan was announced and hyped heavily at the previous WWDC, and it would look bad if it disappeared the month before the WWDC the following year.

We were offered an incentive bonus to stay until October. It was strange to be given 6 months notice. We all had plenty of time to find new jobs, but it was not much fun to go down with the ship. But one interesting side effect was we had plenty of time to prepare for the layoff.

First thing (after all) was to print T-shirts. We printed T-shirts (at Apple's expense) that said "The power to cancel your very best" on the front. On the back was a screen shot of the Dylan IDE with all of our names listed in a window. In front of that was a dialog box that said "Are you sure you want to cancel the entire Cambridge lab?", with the mouse pointer hovering over the "Cancel" button.

By the day of the layoffs, we were ready. We decorated the entire office with gaudy halloween decorations, including a raven with a motion detector that would caw and flap its wings whenever someone walked by. Someone found an advertisement for the "Beverly Hills 90210" with a picture of Luke Perry, whose character was named Dylan. The ad said "Dylan - one step closer to revenge, or one step closer to death?" The "90210" was changed to the zip code for our office in Cambridge, MA, and were posted in the hallways in the office.

When the HR people arrived from Cupertino, we politely invited them into the conference room and served them apple turnovers. I was very proud that one of my coworkers had the presence of mind to think of that! We were all wearing our layoff T-shirts, except David Moon had his "the journey begins" T-shirt on, with masking tape covering the word "begins" and "ends" written on top of it instead. They called us by name one at a time to receive a folder with all of our layoff paperwork. When the first name was called, we instinctively applauded - it had the feeling of a graduation ceremony.

I guess that is the kind of layoff that could only happen at Apple...

A picture of the shirt can be seen here.

[edit] The Death at Harlequin and Functional Objects

Gary M. Palter about Functional Objects and the history of the Dylan project at Harlequin:

In September 1999, Harlequin canceled its Dylan project and laid off the project staff, myself included. In an unusual move, Harlequin transferred the intellectual property rights for its Dylan project to said group. The group decided to continue its efforts to both develop and market its Dylan implementation. Three members of the group, myself included, agreed to commit to a one-year full-time effort to further product development and to raise funding to establish a viable business. We founded Functional Objects, Inc. to pursue these efforts. However, our fund raising efforts were unsuccessful. Functional Objects has been effectively dormant since late 2000. (Quoted from Palter's Resume)

[edit] Dylan's revival as Open Source Project

Nowadays all public Dylan Implementation Projects are maintained as Open Source by the Gwydion Dylan Maintainers. Their wesite can be accessed either via the URL http://www.gwydiondylan.org or http://www.opendylan.org.

[edit] First: The CMU's Gwydion Project became Open Source

CMU's Gwydion Project became Open Source in 1998. Eric Kidd in a message to the Gwydion Hackers about the process:

Andreas Bogk and I rescued the source tarball from oblivion. We fought bit rot, made a web site, and started making releases. Other people showed up, and started contributing code. We got in touch with the Gwydion Group at CMU, and they wished us well.
The Gwydion Group has given up on Dylan. To the best of my knowledge, they've turned down multiple invitations to participate (or even just subscribe to the mailing lists).

[edit] Second: The Harlequin / Functional Object Project became Open Source

Before Functional Objects—formerly Harlequin Dylan—ceased operation in January 2006, they opensourced their repository in 2004 to Gwydion Dylan Maintainers. The open sourced repository included white papers, design papers, documentation once written for the commercial product, and the code for

• The Dylan Flow Machine (the Harlequin Dylan compiler),
• The Interactive Development Environment which provides features like
  • Attaching to running applications
  • High level code browsing code
• The Dylan User Interface Management code (A high level language for GUI programming, which is a Dylan implementation and further development of CLIM ).
• A CORBA implementation
• Access to Microsoft component technology: Component Object Model(COM) / Objct Linking and Embedding (OLE).
• A LispWork-based Dylan Emulator, which was used to plattform independent prototype the dylan language implementation.
• and many more interesting stuff

[edit] External links

• The Dylan Reference Manual
• Dylan - An object-oriented dynamic language (An early description of Dylan with the Lisp/Scheme syntax.)