General talk about software patterns

[Dan Palanza <dan AT capecod.net>]

At 05:42 PM 10/24/2004, Ralph Johnson wrote:

> Paul Graham built a system and a
> company, and sold the company to Yahoo.
> Yahoo took it over and was successful with it, but eventually rewrote it
> all
> in Java.  This is a typical story.  Why do people take
> successful systems in
> Lisp (or Smalltalk, or ...) and rewrite them in much more boring and
> less
> powerful languages?

The answer to this question Ralph could not be more simple: without an
accountable measure of the comparative cost between a job well done and a
job completed quick and dirty the uninformed culture will always choose
quick and dirty. It is ironic that Lisp, which was designed to compute
complex, recursive math problems, which tend to use and reuse data with
continuous histories, also has a proper bookkeeping framework built into
its design: a framework that will deliver the essential cost accounting
that would prove the foolishness of quick and dirty.

> We need to
> understand this if we want to make the world
> safe for powerful languages.

This statement is even more ironic. Mike Beedle pointed to Design
Patterns built into Lisp. I'm pointing to a bookkeeping pattern language
built into lisp. The design-evolution of lisp did not address either of
these domains, yet their design evolved into these pattern solutions.
Could it be that doing the right thing, in resolving the recursive math
that drove Lisp's language design, also is the right thing to do in other
disciplines?

Could there be a greater testimonial to pattern study?

IOW, Lisp demonstrates that there is more to pattern study than
the present OO dominated software culture now understands. What's more,
that such stubborn adherence to OO's half-baked solution is the real
problem in the way of making the world safe for powerful
languages.

Dan