How mature is the current Open Dylan implementation?

Question

Open Dylan looks really interesting. However before I would use it in real development, I would like to know how mature the implementation is. I know that Dylan itself is an old language and it has been used by Apple.

Answer 1

Well, the current implementation, Open Dylan, has been developed since '95 by Harlequin and Functional Objects, before it became open source in 2003.

How is maturity defined? The compiler includes an IDE (Win32 only, sorry), CORBA, OLE, all in all 850000 lines of code. This is (nearly) all Dylan code.

Meaning, unlike other languages, it is self-hosted. The compiler itself is written in Dylan (with an exception of some lines of C (~4000 lines of code) for the runtime/garbage collector binding. The back-ends are either native x86 code or C.

Please do not confuse this implementation with the two others, which are around: Gwydion Dylan (also written in Dylan; developed formerly at CMU, now open source as well), which compiles Dylan to C; and Apple Dylan (closed somewhere in Apples big storage ;).

Answer 2

According to a comment on Hacker News it isn't ready yet. They just started to revive the project.

Answer 3

As of June 4, 2020, the breakdown of files in the OpenDylan project, downloaded from https://github.com/dylan-lang/opendylan, includes:

So you can see that there are 3,112 Dylan files consisting of 30,643,409 total bytes, and also that there are only 104 files in the C Language consisting of only 1,288,062 bytes. And this supports the answer by Hannes, but also sort of quantifies things.

To deemphasize the answer by stesch, which should no longer be considered relevant... This does not look like a "project that's not ready yet". This also does not look like a project just being revived. Therefore, please discount the possibly misleading answer by "stesch".

I research programming languages, and Dylan is my number one pick because: 1. It is founded on Lisp principles, a very solid foundation 2. It is the only Infix Lisp, and was originally created by Apple, who so far has produced an astounding amount of value to their users. 3. Because it is Infix, it will be easier for the common programmer who uses a C-Like language (JavaScript, C#, C, Java, and many more) to be able to learn a great and powerful language. 4. This language has full Lisp macro power. In the C languages, the macro languages there seem bolted-on, a completely different language, and sometimes requires extra parentheses to make it work, leading to subtle bugs. Lisp macros are implemented at a higher level, further along in the compilation process, and also use the same language (Lisp) not a completely different language so it has the same "shape" and is much easier to use. Macro use is much more common in the Lisp languages because it is so much easier, in addition to being more powerful.

Read this, if you are interested: D-Expressions: Lisp Power, Dylan Style

And also this, for an understanding of why and how Lisp macros are powerful: Let over Lambda -- 50 Years of Lisp This is most of the book, online, free to read. I purchased the book for the last few chapters, the one on performance, and the one implementing Forth on Lisp, and then implementing Lisp on Forth.

Domain Specific Languages are a huge tool in our arsenal that we have not done terribly well using. The Macro power of Lisp (and Forth's similar flexibility) allows the on-the-fly definition of DSL's as integral additions to the solution being created. You extend the language -- provide new ways of expressing solutions along side the more usual code.

On a slightly off topic, I sort of like Factor as a better Forth. Created by Slava Pestov, a genius currently working for Apple.

1. Factor Programming Language on Wikipedia

2. Factor Web Site

3. A YouTube presentation on Factor by Slava Pestov

In his video, Slava explains that Factor is based on Forth, but also Lisp. I intend to delve into that to find out what that means, since I've been hopefully looking for the presence of true Lisp-style macro power implemented in other languages.