General talk about software patterns

[Pascal Costanza <pascal AT p-cos.net>]

On 25 Oct 2004, at 11:57, Malte Finsterwalder wrote:

> Ralph Johnson wrote:
>
> > This is a typical story.  Why do people take successful systems in
> > Lisp (or Smalltalk, or ...) and rewrite them in much more boring and 
> > less
> > powerful languages?  We need to understand this if we want to make 
> > the world
> > safe for powerful languages.
>
> I think analyzing the history of Java can give us a lot of information
> about how to make a language successfull.
>
> Analyzing the "failures" of other languages can give us even more
> information.
>
> I think the success of Java is due to:
> 1) Good timing - the Internet hype just started and Java was for the
> Internet

No, Java was originally developed for something very different. It just 
happened to match the idea of applets well. It's interesting to note 
that noone is doing applets anymore. As Paul Graham has stressed 
several times, as soon as you are on the server, it doesn't really 
matter anymore what language you are using. To the contrary, using a 
non-mainstream language can give you a competitive advantage because 
you can take advantage of features that are hard to express in other 
languages.

> 2) Good marketing - Sun made Java heard and told everyone how great it 
> is

Yep.

> 3) Free tools - the jdk was free right from the start and now even
> complete development environments are free (eclipse, netbeans...)

There is another issue here: Languages like Lisp and Smalltalk have 
been rejected by the beginning of the 90's because their runtime 
environments were considered huge (around 5 MBytes). Java came at a 
time when the hardware has just started to catch up with the resource 
requirements of more dynamic languages than C and C++. Nowadays, a 
complete Java installation (Eclipse + JDK) amounts to a 85 MByte 
download, while Lisp and Smalltalk are still moderate. For example, a 
Macintosh Common Lisp installation takes about 32 MBytes on my 
harddisk, and I think the sizes for Smalltalk are similar.

> 4) Standardized but not by committee - There is only one Java and
> changing the language standard and the library happens more quickly 
> than
> in committee-based languages, like C++ for example

...but Java still requires you to know about existing replacements for 
parts of its library. For many ingredients of the Java core API, there 
are many better alternatives around.

> 5) There is a very large standardized library for most of the general
> purpose programming tasks. It may not always be perfect or even very
> good, but it's there

Yes, Java is good at this. Commercial Lisp implementations are quite 
good at this as well, and I hear that Smalltalk vendors also do a fine 
job here. The fact that most of Java is available for free is a 
questionable advantage, at least for commercial projects.

> 6) Platform independent - I think that by now this is the most
> interesting feature of Java

Yep, that's good. However, Common Lisp provides excellent platform 
independence. I have been able to port my AspectL package for Common 
Lisp / CLOS to five different Common Lisp implementations running on 
four different platforms (Unix, Linux, Mac OS X and Windows). In those 
implementations, I heavily mess with the Metaobject Protocol, so this 
are not toy examples.

One of the biggest obstacles for Common Lisp has been the lack of a 
cross-platform GUI library. But this has been solved last year with the 
Ltk binding to Tcl/Tk. See http://www.peter-herth.de/ltk/

Scheme even runs on PDAs. ;)

> 7) It head a smooth migration path for a lot of programmers because of
> it's similarities to C/C++

I can't comment on that.


> Why did other languages fail?
> 1) Not so much marketing and no support by very big companies

Python succeeded in spite of a big company backing it.

> 2) No Standard and a lot of different implementations (e.g. Smalltalk)

...but not the case for other languages.

> 3) Rather expensive tools make it hard to even try the language

Common Lisp comes in both open source and free evaluation versions that 
can get you very far.

> 4) A standard that is developed too slow and the implementations don't
> even fully support it (C++)
> 5) Even for the most general applications you need additional libraries
> to get something done (C++). GUIs are a particular problem here, I
> think. Most Languages don't support GUIs without external tools and
> libraries.
> 6) They look freaky or complicated and are hard to read and/or write 
> for
> beginners (e.g. Lisp)

Scheme is reportedly very easy to learn for beginners: 
http://www.teach-scheme.org/Notes/scheme-faq.html

> Looking at this I see some patterns:
>
> It's a mixture of technical features and marketing, that makes a
> language successfull.
> The design of the language itself is not important. You can't screw the
> design up completely of course, but you don't need to get it
> exceptionally well either. Just a little better than what most people
> are used to.
>
> Underlying all this is: To market a language you need a good business
> case. You need a problem that your language solves better than all the
> other languages. At least you need to make people believe that.
>
> What do you think?

I think it's unlikely that Lisp is going to be the next "big thing". 
(This is a very American way of thinking about things that I don't 
like. Small things are also worthwhile. ;)

Python and Perl are very successful languages in spite of some of the 
characteristics that have led other languages to "fail". So I am 
optimistic that there are other ways to sneak a language into wider 
use. Currently, Common Lisp sees a rise of interested people, so I 
think in a few years we are going to have a reasonably sized community.

Currently, there is a good situation for a "new" language to get more 
widely accepted: Java doesn't live up to its promise to being a simple 
language, and JDK 5 is going to make things even worse. (For example, 
see Bruce Eckel's blog entries about generic types at  
http://www.mindview.net/WebLog - especially the entries "Puzzling 
Through Erasure".)

Now that a wider audience has understood that dynamicity can be a good 
thing and that the available hardware lives up to the demands of a 
dynamic language, something like Smalltalk has a good chance to be 
"the" next language because it doesn't depart that much from Java like 
Lisp would. Since no big company is going to back that, it just takes a 
grassroots appoach and some more courage from people who know about the 
advantages of such languages.

And heck, why not even Smalltalk. I don't believe in the "failure" of 
languages - the field of computer science exists for roughly 50 years 
now, that's nothing compared to other fields. We shouldn't pretend that 
we already know everything about successes and failures.

(Personally, I'd prefer Common Lisp because that language just rocks. 
But since it requires a lot of time and interest to really get it, I 
don't expect it to win big. The attention span of most people is just 
too limited nowadays. Winning moderately is enough. ;)


Pascal

--
Tyler: "How's that working out for you?"
Jack: "Great."
Tyler: "Keep it up, then."