Slashdot Mirror

Maybe if the Dylan community created a killer IDE with a really high-quality implementation, it might still take off...

Have you seen Functional Developer? It's a commercial windows IDE from Functional Objects, and it's recently been open sourced. From zesiger.com's blurb on FunDev:

Also known as FunDev, this is a popular, commercial Windows IDE for Dylan that has just recently been made free to the public. There is talk that it could be open-sourced soon (18 June 2004). It is still being actively developed by the same people who are working on the Gwydion Dylan compiler.

Looks like the blurb is a bit outdated since it's already been open sourced...but anyways, did you know about FunDev when you made a call for a "really high-quality" IDE from the Dylan community?

Of course, besides FunDev, there's Gwydion Dylan, a nice commandline compiler for unix/linux.

You could complain about C all day, the problem is, it's the best thing we have right now.
Hardly.

One of the problem with modern languages is, you can't write an operating system in them.
Sure you can, with little more ASM code than is required for a C-based operating system. Heck, lots of OSs have been written in things like Lisp. Actually, C is a terrible language for writing operating systems. Because its not safe, you have to have an MMU to protect programs from each other. This sucks for performance. Not only do you have the hit of memory protection, but you have to have bounderies between userspace and kernelspace, and between programs. That's why it takes 600(!) clock cycles on my P4 to do something trivially simple like gettimeofday()! If you use a safe language, you don't need memory protection, or even a kernel/userspace boundry for that matter. You get completely fine-grained protection for all objects. See this SF project for an OS written in a safe language.

One of the problems is half the new languages are scripting perl/python like langauges and the rest compile to byte code.
I don't know what's the current fetish with VMs, but most of the really advanced languages (Lisp, ML) compile to well-optimized native code. Look at the recent comp.lang.lisp thread where they ported Almabench to CMUCL, and got within a few percent the performance of C.

Maybe C would go away if there was a compiled langauge that wasn't largely controlled by one company that produced fast code and was portable.
Common Lisp
Another Common Lisp
Ocaml
Scheme
Dylan
Another Dylan

We have lots of languages that are much more powerful than C (hell, they're much more powerful than Java/C#), safer than C, and very close in performance. It is merely a failure of programmers and the software industry that we have not been able to utilize them.

IMHO, the problem with Swing is mostly that it is horribly overengineered and, frankly, that the implementation sucks. It's all in src.jar - read it and tell me if you would hire someone who would present that piece of crap as their prior experience.

Both the free and commercial Dylan compilers produce code that reaches C/C++ speeds.

Dylan is OO from the ground up, and supports a variety of programming styles, including fp, inperative and, of course, oo.

There is no inherent link between s-expressions
and the powerful Lisp macro facility. It is
certainly easier to implement with s-expression
syntax, but can (and has) been done in languages
with infix syntax. See Dylan for example, and Java Syntax Extensions. While neither of these implementations allows using the full power of the language to generate code (i.e., procedural macros), there's no reason that couldn't also be done in an infix language.

It's true that perl is getting more and more of the capabilities of Lisp (as has Python) recently, but while it is becomeing *possible* to do many things, it's rather ugly. Perl doesn't even have a decent syntax for naming the arguments of a function, and Lisp programming is *full* of functions.

Perl datastructures (arrays and hashes) also aren't very well suited to implementing lists, which are likely to turn up in your tasks. Of course you r can *do* it, but it's likely to be more ugly in than in a proper Lisp.

But you before you despair in a maze of twisty little parens, you should realise that there is more than one language in the Lisp family. Common Lisp and Scheme do have lots of parens, but take a look at Dylan. It's a true member of the Lisp family, but looks and feels like a conventional langauge such as C or Pascal.

The link above is to an Open Source command-line compiler for Dylan which workes primarily on Un*x but also has ports to Mac and Windows.

If you happen to be using Windows then also check out Functional Developer, a compiler with a nice IDE and debugger and so forth. It's commercial but the basic edition (whcih is all you'll need) is free.

Dylan is quick to develop in and the programs run fast. A team using Dylan got second place in the recent ICFP Programming Contest.

1) Is lisp less amenable to use by a team? Can't you implement one object while I implement another? I'm asking because I don't know; all my programming has been for my own research.

Actually, if Lisp has one major flaw it's that it allows too much flexibility. That, combined with the fact that a lot of Lisp hackers (I've worked with a lot) are extremely bright, can make it hard for us mere mortals to grok their code.

5) I really don't know what an IDE is. I gather it is something other than emacs, since emacs supports nearly every language, some wonderfully well (try ESS for R). I really can't comment on this one at all; perhaps someone else could?

Dylan is a descendant of Common Lisp and Scheme that has cleaned up some of the warts in CL and uses a C/Pascal-like syntax. Dylan enforces encapsulation via modules. Note that these languages have no such thing as "class scope", and that is a Good Thing, in my opinion.

Harlequin went into receivership late last year and has been bought out by a firm called Global Graphics, who wanted the Scriptworks Postscript RIP (which I used to work on). GG aren't really interested in selling programming languages, so IIRC that arm of the company has been sold off as a different firm, whose name I forget.

However, the really interesting story is Dylan. Harlequin put huge amounts of work into a high-quality Dylan implementation; it's one of the things that sunk the company. When GG took over, they decided that they'd have an impossible task selling the product either to end users or to a company - so they made a *gift* of the source to the developers. They've now set up a company, Functional Objects, to develop it further.

It seems they don't currently plan to open source their implementation; personally I think they're doomed unless they do...
--