[via Chris Double's Radio Weblog ]:

Chris Double reports that the Gwydion Dylan hackers have released fhe first beta for OpenDylan, which is the open sourced version of Harlequin/Functional Objects Dylan implementation. Since it generates native code, it's only available for x86, meaning Windows and Linux. Good thing Macs are going Intel....

In other Dylan related news, the Dylan Hackers placed 2nd in this year's ICFP contest.

Don Box said "Scheme is Love", and supplied a nice reference list.

In the OSAF IRC, PJE said
"I'm beginning to believe that there is No Language But Lisp, and Python Is Its Prohpet. :)"

Patrick Logan posted some pointers to information about T, including a project to revive that fine implementation of Scheme.

The summer after I graduated from high school, I was fortunate to work at Burroughs' System Development Corporation subsidiary, which did some defense work, and some research. I was working on building a compiler for the functional language Super, which was a derivative of SASL. This was the first time that I saw a functional language (we were doing combinator graph reduction), and the first time that I saw a language where indentation was part of the syntax -- they called in the offside rule. Python had not yet been born, but I suppose it's some strange circle of life that I'm once again working in a language with an offside rule.

Lots of important Lisp and Scheme related research came out of the T project, so I'm glad to see it get a little more time in the sun.

Unfortunately, I missed last weeks Seattle Lisp Users Group (I didn't know about it, and I was in San Francisco anyway). One of these days it would be fun to hook with these folks.

Virtual machines and emulators have been around since the IBM 370 (at least). In my actual computing lifetime, the first real emulator that I remember was the 68000 emulator that Apple wrote when they switched the Macintosh to the PowerPC processor. Of course there have been plenty of emulators done since then.

So it really shouldn't have been a surprise that someone has done an emulator for the MIT CADR Lisp Machine. After all Symbolics Genera has been running on 64 bit Alpha's for quite some time now. Of course, there's a difference because you can go download the CADR emulator, and you can't do the same for Genera.

I wonder when someone will sit down and do an emulator for the Intel 432....

Jon Udell has been chronicling his adventures now that there's a Rhino based implementation available.
Meanwhile [ via Lambda the Ultimate, via Chris Double ] Micheal Walter showed how to create an very E4X like XML embedding for Lisp using (character) macros. Why invent a whole new language for a new problem domain?

Last August Guy Steele wrote:

And you're right: we were not out to win over the Lisp programmers; we were after the C++ programmers. We managed to drag a lot of them about halfway to Lisp. Aren't you happy?

I don't know if they got half way or not.

Last night I went to SeaJUG to hear Joe Bowbeer talk about Concurrency Utilities in Practice. This talk is the second of a pair covering the JSR-ized (166) version of Doug Lea's excellent concurrency libraries for Java. Concurrent Programming in Java is an excellent book on concurrent programming in general.

During the talk, I was reminded (again) of Java's great intellectual debt to Lisp. The Future construct which is part of util.concurrent and now java.util.concurrent was originally invented in Multilisp around 1985. It turns out that Juan Loiaza who did some of the work with Halstead was a senior living in the same dorm as me.

This kind of thing is a problem because people don't know where good ideas came from, and so they have no idea of where to look for good ideas when they run into problems that they don't know how to solve.

Bill Clementson is doing a series on Lisp books. His summary article is great and was preceded by two articles on about On Lisp, and the other about SICP. The articles were great because the pointed to online copies of these great texts, which allow for searching. \

Actually, this one was for Patrick Logan [via Cooking with Lisp], but hey...

And this quote [via Patrick Logan]:

Question: "Why are languages like C , C#, and Java so prevalent?"
Dave Ungar: "Why do people smoke tobacco?

Patrick has been on a tear lately....

If you are interested in object systems, you really ought to be exposed to CLOS.

Richard P. Gabriel made his CLOS papers available. (via Pascal Costanza in comp.lang.lisp)

[via lispmeister]

I've suspected Don Box of being a "sympathizer" from various small comments he's made over time. But a few days ago he confirmed it.

Planet Lisp now has an RSS feed

We're overdue for a Lisp related posting, so here we go:

Lispmeister is a new Lisp related blog that reported that some folks at ILC were trying to convince Howard Shrobe to open source Open Genera, the version of the Symbolics environment that runs on Alpha. These folks were all excited about a port of Open Genera to AMD Opteron or Athlon64. But what about PowerPC 970? All those G5 owners are just Lisp Machines waiting to be booted.

[via Lambda the Ultimate] Apparently Dan Friedman has revised his paper on Object-Oriented style. So if you want to see an example of Scheme macros in action, you should definitely look at this.

I have a paper copy of the MIT Lisp Machine manual out in my garage, but Hans Nowak posted the location of an electronic copy. This is a wonderful find, if you are interested in the history of Lisp and what Lisp Machines could do.

Lemonodor has a post and comments on Smug-lisp-weenie-ism. I hope that my postings haven't fallen into that category. I've been trying to keep the posts educational, although I know I haven't always succeeded.

I do think that there are some valid points in the comments:

1. There are too many Lisps/Schemes/etc.
2. It would be better to show cool programs/applications

Python is attracting a lot of people who like Lisp. There's only one Python, and there's starting to be a body of interesting programs. There's momentum there, quite a bit more than there is around all the various Lisps. I think that the momentum around languages like Python and Ruby is going to open a window of opportunity for Lisp and Smalltalk. The question is will those communities be ready when the window opens? This is something to be thinking about now. I've been excited about Arc, but we're coming up on the third LL conference, and there's no Arc in sight. Seems like a cathedral being built out there somewhere. In the meantime, Arc has sucked up all the oxygen from Lisp and other Lisp like languages like Dylan. In order to be ready for the window to open, we need something to work with. I've been hoping that Arc would be the standard that everyone in the Lisp community could rally around, but I'm starting to wonder if that's a mistake. Paul Graham is giving a talk on Arc at the ILC later this month. Let's hope he actually shows us what Arc looks like so we can decided whether to pile on, or to go find something else. Perl, Python, and Ruby are demonstrating that the combination of non-mainstream language ideas and open source can gain buzz and adoption. Why can't Lisp?

In his reply to my post about macros, Avi Bryant brings up one of the differences between Smalltalk environments and Lisp environments. Some Smalltalk environments can version at the method level, but Lisp environments version text files. The only Lisp (related) environment that had the notion of methods being independent of files was the Apple Dylan environment, which is quite dead now. Gwydion and Functional Developer have gone back to files. But here was environment for a language that included macros, that was similar in spirit to a Smalltalk environment.

[via Chris Double's weblog]: Andreas Bogk is running Gwydion Dylan right on top of the L4 microkernel, including a VGA character screen driver written in Dylan.

Phil Windley writes about Phil Wadler's The Essence of XML:

Of course, as Phil points out, LISP s-expressions have both of these properties. This doesn't necessarily imply that s-expressions would be a good substitute for XML. One of XML's great features is that its parsers work as interpreters rather than being compiled. That is, they update their syntax on the fly as they work rather than having a syntax compiled in, as is the case with s-expressions or other representations

I think that macros (and if need be, reader macros) would allow s-expressions to do most of what is needed here.

Joey Gibson has discovered that Lisp Macros Are Very Cool. Wait till he sees some of the cool stuff in R5RS...

This year at the Lisp Conference, they are having a talk by Daniel Friedman (one of the Giants of Scheme) from Indiana University on "Object-Oriented Style". Daniel is going develop an "object-oriented style" in the same way that Lispers have used a "continuation passing style". Included in his keynote is a set of exercises. The Scheme code that you need to work through those exercies is also available.

I've only briefly looked over the paper (I think I want to try the exercises), but one of the comments in the conclusion was interesting:

Macros have come a long way from the early days of Lisp. Now, with hygiene, and with-syntax, syntax-case, etc., we see that macros are powerful enough to write sophisticated compilers. More importantly, the compiler can be written so that the expressions are not traversed by the code written by the macro writer.