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

promoting dylan

Dylan is such a great language, that I am very disappointed by the
little numbers of its users and suppliers.

As it comes very close to something like the 'ultimate programming language'
I would dare to see as many programmers code (and think) in dylan as in
java.

But how to achieve this? In my opinion we need to associate dylan with
some new 'mega-trend'. This was the key to the success of java: java and the

internet are almost synonyms.

But what could be connotated with dylan? 

- MacOSX: If availabe on Intel hardware, this might become (over 5 yeras or
so)
                 a big competitor to Windows. So, maybe, try to establish
Dylan
                 as the premier programming language for MacOSX.

- 3rd-Generation-Wireless-Phones-PDA's: High-Bandwidth cellular phones/PDA's

                are the next big thing. 'A computer in every pocket' might
be the slogan,
                but they will surely surpass desktop computers in volume in
less than
                5 years. Maybe we should try to associate Dylan with these
devices of
                the future. Define an 'Embedded Dylan' subset and spend more
thoughts
                on compile-time gc or explicit deallocation, and resource
minimization in 
                general (a weak point of dylan IMHO). Ironically Apple
announced Dylan as
                the language of their Newton devices a decade ago, but as we
all know...
               (newton-script, not bad though).

- Domain Specific Languages: Class-Libraries and Frameworks define terms
(types) to operate
               upon. In effect, they provide the vocabulary of an (abstract
syntax) language on top of 
	   the implementation language. With a powerful macro-system you
could build a specific
               concrete syntax for these and thereby ease programming. This
is clearly one of
               the major assets of Dylan and should be promoted much more.
But still need a key reference.

- Aspect oriented Programming: Interesting thoughts from PARC on the future
of 
               object oriented programming. Some things still don't make it
easily into components, like
               exception-handling, logging, synchronization, licensing,
distribution etc. and need a more
               global point of view. Aspects try to locate these tasks in
one place under one abstraction, but
               with global effects. 
               Dylan clearly separates protocols (set of methods over types)
from types and thereby allow
               multiple views (aspects) to be defined upon types. The macro
system might produce the global
               effects needed. (BTW, whats the best way to code before and
after methods in Dylan?).
               So, as AOP might become a trend, Dylan could/should be the
language of choice.

Ok, just some ad-hoc ideas. I am a litte bit afraid that this wonderful
language doesn't stand a chance
against java (which is just cold-coffee if you ask me:-)

marc
Follow-Ups: