History of the Dylan programming language

From Wikipedia, the free encyclopedia
Jump to: navigation, search

Dylan programming language history first introduces the history with a continuous text. The second section gives a timeline overview of the history and present several milestones and watersheds. The third section presents quotations related to the history of the Dylan programming language.

Introduction to the History[edit]

Dylan was originally developed by Apple Cambridge, then a part of Apple's Advanced Technology Group. Its initial goal was to produce a new systems programming application development language for the Apple Newton PDA, but soon it became clear that this would take too much time. Walter Smith developed NewtonScript for scripting and application development, and systems programming was done in C. Development continued on Dylan for the Macintosh. The group produced an early Technology Release of its Apple Dylan product, but the group was dismantled due to internal restructuring before they could finish any real usable products. According to Apple Confidential by Owen W. Linzmayer, the original code name for the Dylan project was Ralph, for Ralph Ellison, author of The Invisible Man (reflecting its status as a secret research project).

The initial killer application for Dylan was the Apple Newton PDA, but the initial implementation came just too late for it. Also, the performance and footprint objectives were missed. So Dylan was retargeted towards the general programming audience. To compete in this space it was decided to switch to Infix notation.

Andrew Shalit (along with David Moon and Orca Starbuck) wrote the Dylan Reference Manual, which served as a basis for work at Harlequin (software company) and Carnegie Mellon University. When Apple Cambridge was closed, several members went to Harlequin, which produces a working compiler and development environment for Windows. When Harlequin got bought and split, some of the developers founded Functional Objects. In 2003 Functional Objects contributed its repository to the Dylan open source community. This repository was the foundation stone of the open source Dylan implementation Open Dylan.

In 2003 the dylan community had already proven its engagement for Dylan. In summer 1998 the community took over the code from the CMU Dylan implementation known as Gwydion project and founded the open source project Gwydion Dylan. At that time CMU had already stopped working at their Dylan implementation because Apple in its financial crisis could no longer sponsor the project. CMU therefore shifted its research toward the main stream and shifted towards Java.

Today, Gwydion Dylan and Open Dylan represent the only working Dylan compilers. While the first is still a Dylan-to-C compiler, Open Dylan produces native code for Intel processors. Open Dylan was designed with the Architecture Neutral Distribution Format (ANDF) in mind.

Timeline Overview[edit]

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)..." ( Quotation 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." [1]

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 MacTech [2]

August 1994: After Apple distributes Dylan CDs at WWDC, folk singer Bob Dylan sues Apple for trademark infringement.[3]

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 [4]

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 ).[5]

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: Andrew Shalit announced the Service Pack 1 for Harlequin Dylan 1.2 in the dylan newsgroup.

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: Functional Objects announces the availability of Functional Developer 2.0.1 and 2.0 service pack 1.

2003: Functional Objects opensources its internal Dylan repository to the Open Dylan Community.

History by (mostly) quotations[edit]

The roots of the programming language Dylan[edit]

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[6]
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 [7]

The acknowledgments from the First Dylan Manual (1992) states:

Designing Dylan has been a work of many hands.
The primary contributors to the language design were Glenn S. Burke, Robert Cassels, John Hotchkiss, Jeremy A. Jones, David A. Moon, Jeffrey Piazza, Andrew Shalit, Oliver Steele, and Gail Zacharias.
Additional design work and oodles of helpful comments were provided by Jerome T. Coonen, James Grandy, Ike Nassi, Walter R. Smith, Steve Strassmann, and Larry Tesler.
Many more people provided invaluable feedback during the design. Among these were Peter Alley, Kim Barrett, Alan Bawden, Ernie Beernink, Rasha Bozinovic, Steve Capps, Mikel Evins, Gregg Foster, Jed Harris, Alice K. Hartley, Alan Kay, Larry Kenyon, Matthew MacLaurin, John Meier, Richard Mlynarik, Peter Potrebic, David Singer, David C. Smith, Bill St. Clair, Andy Stadler, Joshua Susser, Michael Tibbott, Tom Vrhel, Bob Welland, and Derek White.
Moral and logistical support were provided by Donna Auguste, Chrissy Boggs, James Joaquin, Rick LeFaivre, Becky Mulhearn, David Nagel, Mark Preece, Mary Reagan, Shane Robison, and Susan M. Whittemore.
The Dylan project was directed by Ike Nassi.
This manual was written by Andrew Shalit with contributions from Jeffrey Piazza and David Moon.
The manual was designed by Scott Kim and Steve Strassmann. The typefaces are the Lucida family and Letter Gothic. The cover was designed by Scott Kim.
The Dylan project was funded entirely by the Advanced Technology Group of Apple Computer.

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.

CMU still provide an information page about Gwydion.

Harlequin

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

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 John 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."

End of Dylan as commercial product[edit]

Project Death at Apple in 1995[edit]

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.

Gabor Greif:

Spindler, CEO of Apple at that time, stopped Dylan because the engineers working on it were more expensive than Apple could afford back then. Till the end of '95 the core team got a chance to wrap up all they had and package it as a product which came out as the Apple Dylan Technology Release. It featured PPC code generation but did not itself run on PowerPC natively. The development bed was all Common Lisp and there was no PPC MCL (Macintosh Common Lisp) at that time. Later Digitool was paid to port the environment to PPC using their development version of MCL for PPC they were working on. Apple Dylan TR PPC was quietly released 1996. It still runs fine on classic MacOS, dunno about X
The team sometimes hinted that not bootstrapping the environment in Dylan was a mistake. This would have eased the PPC adoption considerably. But in the light of limited resources and a very strong CL background of the members it was understandable.

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):[8]

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.[9]

The Death at Harlequin and Functional Objects[edit]

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)

Dylan's revival as Open Source Project[edit]

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

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

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).

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

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) / Object Linking and Embedding (OLE).
  • A LispWork-based Dylan Emulator, which was used to platform independent prototype the dylan language implementation.
  • and many more interesting stuff

References[edit]

  1. ^ "MADA at MacWorld". MacTech 7 (5). 1993. Retrieved 6 December 2013. 
  2. ^ "SFA Atlanta 1994". MacTech. 1994. 
  3. ^ Linzmayer, Owen. "Blowin' Smoke in the Wind". 
  4. ^ "Digitool". Retrieved no longer accessible. 
  5. ^ Fahlmann, Scott (12.09.1998). "Optimised Dispatch". comp.lang.dylan. 
  6. ^ "NEMADA Notes". MacTech 7 (1). 1993. Retrieved 6 December 2013. 
  7. ^ MacTech 11 (8). 1997. 
  8. ^ "apple.computerhistory.org". Retrieved no longer accessible. 
  9. ^ "Dylan T-Shirt". Retrieved no longer shown. 

External links[edit]