[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Dylan (was: ARC)

Dan Weinreb:
> Yes, this is part of the "network effect" that was (I think) the main
> point of my little speech at the LL1 conference.

Yes, you did say that.  And perhaps my (not original) point about playing
well with other's libraries could be stated as: join a preexisting network.

> And, in my opinion,
> which is a particularly humble opinion since I know so little about it
> but I'll say it anyway, this was always the main problem with the
> question of how Dylan was going to "succeed" -- it was never clear how
> the critical mass needed to achieve the required positive feedback
> loops was going to get started.  (At least, when I asked my friends
> who were working on Dylan how they intended to do this, they didn't
> seem to have any strategy that they could articulate to me.)  Of
> course, my assertion above is using a somewhat circular definition
> of "succeed"; Dylan succeeded in other respects, of course.

Dylan was going to succeed because there was a new niche --- PDAs --- and by
going in as both the systems and application programming language for the
Newton, Dylan would capture all the innovative programmers (those who would
be eager to try programming a PDA would be eager to try a new language).

After Dylan got booted off the Newton, the new spin was that it would be a
more productive language for application development, and that the obstacles
that kept Lisp from winning --- Common Lisp was large, kludgy, and hard to
subset, and Lisp executables at the time weren't competitive in size or or
speed with C or Pascal programs --- would be gone with Dylan's sealing and
legacy-free design.  We realized this was a weaker strategy (beat C and
Pascal at their own game), but it was what we had left.

There was some other language in development around the same time, that was
also more dynamic than mainstream languages (had dynamic loading and garbage
collection) and also targetted small mobile devices but got kicked off them
too.  That language's developers decided to retarget it at delivery of web
applications instead of competing with desktop application programming, and
Java today has somewhat more of a following than Dylan.

We called this the "killer app" model of language development, and it makes
a nice story.  Regular expression searches are the killer app for Perl;
client-side web page interactivity is the killer app for JavaScript;
server-side web page generation is the killer app for php.  I think it's
worth looking at language success in terms of this model.

There are, of course, other stories that could be told about Java versus
Dylan, that incorporate other differences such as: Java's bytecode
interpreter versus Dylan's series (ARM, 68000, PowerPC) of compiler
back-ends, and the ensuing development cost and portable; security versus
sealing (which aren't theoretically exclusive, but there's only so many
developer resources); running on Windows and Linux versus just the Mac; text
files and make versus source database and IDE (and the development costs of
these); and lastly the financial resources that Sun and Apple could commit
in the early nineties.  Probably all of these stories are true.