EvolutionOfLanguagePreference

Speaking quickly, and with no thought to the practicalities:

Some sort of self-modifying, 'evolvable' language would be cool. I think Lisp attempts to be like that with macros and such. Use the pre-existing small bricks to build bigger bricks. Or one that lets you blend an arbitrary bunch of other languages, along the lines of C's 'asm' keyword (I think?), where you can embed a bunch of assembler in a C program if you need to. In Java terms, the ability to interact directly with a running JVM might be cool, so you could implement spin-locks (check and set a lock atomically) and other low level stuff etc.

On a more general level, its interesting to me to look back on my own changing opinions. When I first started programming for a living, Java was the language I started in, so its the one I'm most familiar with. I used to think it was almost perfect. I'd heard of multiple inheritance, and why it was bad, and why Java was good for not having it. Same with object destructors etc. Things were fine for a while. Then I started hitting my head on the glass ceiling. Multiple interface inheritance was fine for most things, but sometimes multiple implementation inheritance was the 'right' thing. Having to reimplement the same methods, or pass in an extra object to delegate the calls to wasn't optimal. And the benefit of explicit destructors becomes apparent the first time the JVM crashes with 'Too many open files' cos you forgot to close a FileReader? before it went out of scope. (Actually I'm not sure if a destructor would have helped here, but I refer you to the first line of this page).

So now, I find myself wishing for an advanced form of Java, a 'Java++' if you will. The wish list for which looks something like this:

• Runs all vanilla Java apps. (hardly needs saying).
• Allows fine grained control over which advanced features are turned on, so you can tune it to your team's skill level.
• Allows multiple inheritance of both interface and implementation.
• Has explicit (but optional) destructors that are called as soon as an object goes out of scope (making 'finalize' actually work would be a good start).
• Allows low-level interaction with the JVM (and possibly even lower). A language should not make any assumptions about what a developer might want to do with it. Paul Graham's pieces on Lisp make some good points on this.

• Any others?

On reading the list, it looks like I'm asking for C++, but that's not the case. It has too much that's bad, along with the power. eg. header files, malloc/free, wierd pointer arithmetic etc.

--DarrenH³host³³date³July 30, 2002³agent³Mozilla/5.0 (Windows; U; WinNT4?.0; en-US; rv:1.0.0) Gecko/20020530³EvolutionOfLanguagePreference