A raft of language postings today: Carlos weighs in with pointers to the "Objects have Failed" debate held at OOPSLA 2002, where the opposing positions were represented by Guy Steele and Dick Gabriel. The two essays are "the glass is half empty" and "the glass is half full". Instead of looking a whether objects have succeeded or failed I think we need to look at what is still unfinished.  Regarding this, Steele said

Now, objects don't solve all the problems of programming. For example, they don't provide polymorphic type abstraction (that is, generic types). They don't provide syntactic abstraction (that is, macros). Procedural programming still has its place in the coding of methods. But to say that objects have failed because they don't solve all possible problems is like saying carbohydrates have failed because you can't live on pure sugar.

As I read Gabriel's essay, it seems that you could boil a lot of his argument down to more simplicity and more dynamism, particularly in the types domain.  There were one or two other interesting points that were made:

Powerful concepts like encapsulation were supposed to save people from themselves while developing software, but encapsulation fails for global properties or when software evolution and wholesale changes are needed. Open Source handles this better. It’s likely that modularity—keeping things local so people can understand them—is what’s really important about encapsulation.

I think that this an interesting observation as to where language constructs facilitate objectives vs when process facilitates those objectives.

Objects require programming by creating communicating entities, which means that programming is accomplished by building structures rather than by linguistic expression and description through form, and this often leads to a mismatch of language to problem domain.

This sounds to me like a call for additional support for metalinguistic abstraction, which is what macros are all about.

In the vein of what's left to do, as I was looking through Gabriel's notes I saw many quotes from William Cook, who preceded me both at Brown and at Newton, so I did a little googling and found his home page.  And lo and behold, there's a presentation with his ideas on what's left to do.  The things from his list that resonate with me:

• Postmodernism - a collage of paradigms (particularly things like persistence and XML).  There was a paper from Erik Meijer and Wolfram Schute on this blog today.
• Descriptive Language - I see better support for metalinguistic abstraction as a key here.
• Linearity - "A change in requirements is proportional to the change in implementation". Will claims this is more important than encapsulation, modularity, and reuse. I'd say that linearity is what those things are trying to enable.  It doesn't hurt that he got this idea from Sussman.
  
• Domain-Specific modeling - macros is normally what I think of here. It was interesting to see his adidtions of generative programming, meta-programming, and staged-computation

Winding up todays PL entry is a posting from John Lam which referred to the Code Generation Network and a really good interview with Dave Thomas.  I'm really going to need to go read the Pragmatic Programmer, because the more I read of Thomas, the more I like what I read.  I like the way that he separates code generation as a smell versus code generation as a way of implementing "Don't Repeat Yourself" (DRY).  Seems to me that DRY is also a way of getting Linearity.  The other thing that was interesting was his example code generator in Ruby, in which he uses active code and Ruby's ability to run code a class definition time (sounds like macros/MOP to me).  I need to go find out how to do this in Python -- the metaclass documentation leaves a bit to be desired.  I'm probably going to need to go take a serious look at Ruby, just so that I can be informed.