Ben Hyde is calling me an old fart because of my nostalgia for OpenDoc. I guess you could call it nostalgia. I think it's more than that. In his post, Ben points out that it was difficult for Apple to gain adoption for OpenDoc because it threatened the business model of existing ISV's. We don't have that problem in the same way on Linux. Yes, we have existing apps. But the authors of most of the Gnome apps don't have a business model (except maybe for Ximian). So there's the potential to remove that barrier to adoption. Also, I think that we are ready for a compound document like system -- microcontent is going to drive it. Whether it's the whole system or whether there's a compound document container application, doesn't really matter to me. Ben thinks that the inter-machine issues have taken precedence over the intra-machine ones. I think that the next step that we'd like to take in capitalizing on the inter-machine capabilities that we have, will necessitate improvements in the intra-machine area. In terms of big picture ideas, open source is running out of things to copy. Here's something that hasn't been done yet.

Edd Dumbill describes his experiences wrapping GTK's libegg for Python. This is cool stuff, and something I want to look into a bit more once the book is done.

Oliver Steele, the Chief Software Architect at Lazlo Systems, has a great explanation of the argument for implicitly typed languages in the presence of a rigid unit test discipline. He's also got some screenshots from Apple Dylan, showing the IDE. Note that this is circa 1995.

Last night after SeaJUG, while Wilhelm was showing me his TiBook, I was showing him Daniel Friedman's Object-Oriented Style paper. I was showing Wilhelm the three versions of the hairy page long macro when Jason Marshall turned around, heard what we were talking about, said "why don't you just use Objective Caml?", and then returned to his conversation. So I was amused to see this morning's Slashdot piece on mod_caml, which is like mod_lisp but for OCaml. The Slashdot comments actually have comparisons of Ruby and OCaml code for scripts. Kind of interesting.

Also happening today, je_apostrophe found this quote by Joe Marshall on the LL1 list with a specific list of complaints against Java:

    1.  No syntactic abstraction (macros)
    2.  No multiple inheritence
    3.  Single dispatch
    4.  C-like syntax
    5.  Verbosity
    6.  Expressions and statements that are not interchangable
    7.  In general, no tail recursion.
    8.  Dichotomy between primitive types and class types
    9.  No MOP

I'd add another one - no REP loop.

So what happens if we take Joe Marshall's list and apply it to the language that Jason Marshall is championing (Objective Caml)? Let's go point by point:

1. Nope, no macros
2. Multiple inheritance is there
3. No multimethods
4. ML syntax
5. Not too verbose
6. It's a functional langauge, it's expression oriented
7. Handles tail calls and tail recursion
8. No problems here
9. No MOP
10. (Mine, must have a REP loop) - Yep REP Loop included.

Well, 6/10 certainly better than Java. And I think that OCaml would definitely be a step up from Java. But the absence of syntactic abstraction is a big problem for me.