ten recipies for dead parrot ( order Psittaciformes)

[Steven D. Majewski]

[ Sent to comp.lang.python, because some threads there on JPython,
Acquitition, Metaobject Protocols and patterns was the inspiration
for this post. ( There is more unity is this thread that is apparent! )
Sent to comp.lang.misc, because some of this is more general and the
type of stuff I would have put on my Programming Language Critiques
page if I had the time to actually maintain it. :-(
Please trim your followups if appropriate. ]

Several reports from IPC6 <http://www.python.org/workshops/1997-10/>
in comp.lang.python have mentioned the presentations on JPython
( Python implemented in Java & Java VM ) and JPI - Java Python Interface
(which allows Java access to Python classes and Python access to Java
classes).

Sunscript has taken a similar dual approach - they recently announced
"Jacl & Tcl Blend 1.0 alpha 1 Released" <http://www.sunscript.com/> :

| Tcl Blend allows you to load and interact with the Java VM from
| tclsh or wish. Jacl is a new 100% Java implementation of Tcl 8.0.

BTW: The canonical list of "Languages for the Java VM" is at:
<http://grunge.cs.tu-berlin.de/~tolk/vmlanguages.html>
You should add JPython, et.al. to the list when there is something
posted to the web: <mailto:to...@cs.tu-berlin.de> with additions.

Some sort of Java/Smalltalk integration has often been a topic on
comp.lang.smalltalk, but the big excitement there seems to be reports
of Alan Kays talk at OOPSLA97 and Squeak. Squeak is Smalltalk done
over from scratch ( by some of the original Smalltalkers who felt
that commercial smalltalks were growing away from some of the original
ideas) written in Smalltalk ( compiled/translated into C for performance,
but it still allows metaprogramming and modification of the lowest levels
of the system. )

The OOPSLA paper has some interesting ideas on implementation that
might also be useful and applicable to Python, Scheme, Logo, et.al.

"Back to the Future: The Story of Squeak, A Practical Smalltalk Written
in Itself" by Dan Ingalls Ted Kaehler John Maloney Scott Wallace Alan Kay

<ftp://ftp.create.ucsb.edu/pub/Smalltalk/Squeak/docs/OOPSLA.Squeak.html>

There are a couple of trip reports from OOPSLA:

Report on OOPSLA97
<http://www.cc.gatech.edu/fac/mark.guzdial/squeak/oopsla.html>

has some quotes from Kay's talk. ( A few excerpted here, some of
which I will get back to.):

>
> There is not a single atom or line of code in today's Internet from the
>original ARPAnet, even though it has magnified itself eight orders of
>magnitude -- and has remained up through all that growth!
>
>Java and C++ make you think that the new ideas are like the old ones. Java
>is the most distressing thing to hit computing since MS-DOS.
>
> For complex systems, the compiler and development environment need to be
in
>the same language that its supporting. It's the only way to grow code.
>
> If you think programming is a small thing, that's why your programs are
so
>large.
>
> The Art of the Metaobject Protocol is the best book written in computing
>in ten years.
>
> Simula to OOP is moving to new things. Simula to ADT (Abstract Data
Types:
>C++, Mesa, Ada) is moving on to better old things.
>

And Jeff Sutherland's notes from
OOPSLA'97 "Squeak" Birds of a Feather Session
<http://www.tiac.net/users/jsuth/oopsla97/squeak.html>

Some other info and some screen images from Squeak can be seen at:
Basic Aspects of Squeak and the Smalltalk-80 Programming Language
<http://www.cosc.canterbury.ac.nz/~wolfgang/cosc205/smalltalk1.html>

Besides learning from some of the implementation techniques of Self
and Animorphic Systems ( Animorphic Systems was a small company that
included several members of the Self team and produced extremely high
performance virtual machines for Smalltalk and Java. The company has since
been purchased by Sun Microsystems and their technology is going to be
incorporated into the JVM. ), Squeak uses the Morphic interface from Self.

On the topic of language implementation techniques -- I'm currently
reading: "An Introduction to Scheme and it's Implementation" - a draft
in progress by Paul Wilson.
<ftp://ftp.cs.utexas.edu/pub/garbage/schin2up.ps>
I'm only a couple of chapters into it, but so far, it's very readable
and it has a very good explaination of "everything is a pointer" --
something in common with Scheme, Python and Java semantics that often
confuses people comming from the C/C++ world. ( The PS version is newer
and better, but an earlier bit of that chapter is online at:
<ftp://ftp.cs.utexas.edu/pub/garbage/cs345/schintro-v14/schintro_30.html>)

I've also dug out to reread and old but good survey paper:
"TR93-27:Representing Type Information in Dynamically Typed Languages"
by David Gudeman available from:
<http://www.cs.arizona.edu/research/reports.html

The links on Squeak led me to:
"The Cathedral and the Bazaar" by Eric S. Raymond
<http://www.curtisfong.org/~nyet/cathedral/cathedral-paper.html>
which is a wonderful paper about Eric's experiment in "Bazaar style"
development ( ala Linux ). This is a good companion to Gabriel's
MIT vs New Jersey dichotomy is his 'worse is better' paper:
http://alpha-bits.ai.mit.edu/articles/good-news/good-news.html
Both have to do with how design and the culture of programming
interact.

He does mention that Gabriel paper, as well as Peopleware, Brooks Mythical
Man Month, and the Psychology of Computer Programming in his references.
He doesn't mention Gabriel's more recent "Patterns of Software" which
has some even better explorations of the difference between designed
and evolved ( "Jes' Grew" ).

[ Back to Alan Kay's quote: ]
> There is not a single atom or line of code in today's Internet from the
>original ARPAnet, even though it has magnified itself eight orders of
>magnitude -- and has remained up through all that growth!

From reading the History of Smalltalk in HOPL-II, and these Squeak papers,
it's clear that one of the things Kay has been after in these systems is
that magical ability to rebuild the foundations without falling thru the
floor!

Most of the interest in patterns and the Gang of Four is in Alexander's
idea
of a pattern language, but this notion of habitability that is common in
the
above references is just as important -- Which brings me to repost ( I hope
he
doesn't mind ) a message from Michale A. Beedle to the Patterns Discussion
mailing list that I've been keeping in a safe place for a while -- which
contains a good summary of Alexander's statement of those principles:

From: Michael A. Beedle <bee...@fti-consulting.com>
To: Patterns Discussion \(E-mail\) <patterns-...@cs.uiuc.edu>
Subject: A rare quote

>
>I keep in among my bookshelves a separate section for classics. In that
>section, you can find things like MMM by Fred Brooks, or "Literate
>Programming" by Knuth.
>
>One of the books that is there, but that I had not opened for quite a
>while, is "Principles of Software Engineering Management" by Tom Gilb. A
>book that came out in 1988, and ever since has been referenced as one of
>the most comprehensive and influential titles in software engineering.
>
>I read most of the book earlier, but I never read chapter 15 in detail,
>because it dealt with "Some deeper and broader perspectives on
evolutionary
>delivery and related technology", and at the time I was looking for
>pragmatics not new directions. In fact chapter 15 is a thorough annotated

>bibliography which ranges from Tom Peters "In Search of Excellence" to
>...., yes, patterns and Alexander.
>
>Alexander is referenced as one of the leading architects among Frank Lloyd

>Wright and Victor Papanek. Gilb enlists the major principles of applying
>patterns as:
>
>1. The principle of organic order - emergence of the whole guided by local

>acts
>2. The principle of participation - all decisions come from the user
>3. The principle of piecemeal growth - budgets are weighted overwhelmingly

>towards small projects
>4. The principle of patterns - al design and construction will be guided
by
>a collection of communally adopted planning principles called patterns.
>5. The principle of diagnosis - the well being of the whole will be
>protected by constant diagnosis
>6. The principle of coordination - the slow emergence of the whole through

>organic order will be assured by a funding process which regulates the
>stream of individual projects put forward by the users.
>
>Isn't that what the gurus preach now, architectural centricity, user
>involvement, and iterative incremental life-cycles? Alexander saw that a
>long time ago and Gilb recognized it as important for software development

>- remember this was the 80s!!! the high time of Waterfalls!!!
>
>This is how Gilb finishes the section on Alexander:
>
>"The ideas here are quite exciting and revolutionary - we must wonder who
>will be the people to document that they have applied such rules in
>software development?"
>
>I bet you Tom had no idea this was going to be one of the major trends of
>software architecture 10 years later. What amazes me was his vision, he
>saw it before it happened, and I think he deserves some credit for it.
>
>Sort of makes you think - can we see what is going to happen in software
>architecture in the next 10 years?
>
>- Mike Beedle
>http://www.fti-consulting.com/users/beedlem/
>

Now -- where's my old copy of the Art of the MOP? ...
-- Steve Majewski
<sd...@Virginia.EDU> <http://galen.med.virginia.edu/~sdm7g/>