Quote:
> And here comes the question. How many of you guys are actually proficient
> with Smalltalk ? I have heard that they are pretty close... :)
I worked for ParcPlace Systems for 2 1/2 years. That job ended about five
years ago. I consider myself "conditionally proficient" in Smalltalk,
though I don't consider myself absolutely proficient with today's Smalltalk
because I haven't officially worked with the language other than cursory
glances at Squeak, Dolphin, and VWNC since I left PPS - and there's been a
LOT of changes since then. That having been said, I still think that
Smalltalk is less powerful than Lisp. Things I missed when I was
programming in Smalltalk:
Macros - Even though I did a lot of code that "wrote code" in Smalltalk, it
always seemed like a real hack cobbling up that heavy syntax. In addition,
not having the code evaluate itself automatically made the macro-like code
in Smalltalk still less nice. I was grateful that I could do it at all,
though - I shudder to think what the Java types are doing now...
Mixins and around/before/after methods - When I was working for PPS, CLOS
was out there. Lisp programmers had been using multiple inheritance since
the Flavors days. I missed mixins and around and after and before methods
because they were so nice notationally in Lisp. Yes, I know you can
simulate them in ST by using a send to super at the proper place in an
inherited method but it really is sort of clunky having to maintain the
syntax.
Multi-methods - After using Lisp for a while, you start to realize what a
crock double dispatch is. 'Nuff said.
A real MOP - Smalltalk had a "sort of" MOP. In general, you couldn't modify
method lookup, object layout, etc. because it was all hardwired into the VM.
Again, you could bypass the problem with liberal use of proxying and MNU
hacking, but only with a huge increase in code and corresponding decrease in
performance. Most CLOS implementation shave enough of a MOP to allow you to
do almost anything you want to the CLOS system.
&optional and &rest parameters - I added the equivalent of &rest parameters
to VW by modifying the compiler. It was a cute hack, but performed like
{*filter*}most of the time because it had to go through the MNU mechanism too
often.
There were a few other things (really good programmability of the parser,
read-time evaluation, etc., come to mind), but I don't want to belabor the
point. Now having said that, there are a few things I miss in Lisp that are
available in Smalltalk:
Assurance of a GUI being in the implementation - They may not be standard
but at least it's always there. No one would accept a Smalltalk without a
GUI as a legitimate Smalltalk (no matter what the standard says), so it's
always there. Many lisps don't come with GUI's as standard. This limits
their usefulness in many business apps.
Nice steppers, browsers, the whole toolset enchilada - Yes, most of the
commercial lisps have these, too, but they're not as standardized in concept
as Smalltalk's and they don't seem to work as well.
And finally, things I miss in both:
Portable binary format - You may not be able to have write-once,
run-anywhere, but being able to transport core code in binary form from
implementation to implementation sure would be handy. This would mean a
standardized image and byte-code set for Smalltalk and portable FASL format
for Lisp systems.
Standardized FFI - Again, just a common way to describe and call C functions
with standard methods for converting from the Lisp/Smalltalk world into the
C world (and vice versa) would be nice. #+feature may be more terse and
localizable than a C #ifdef, but at its core it's still an ifdef and the
fewer of those you need, the better. And Smalltalk doesn't even have a good
way of dealing with this, so you have to mess around with platform-specific
classes and Abstract Factory patterns - yuck...
So, bottom-line, where do I stand? If I had to do a business app that
needed a GUI, I'd probably go with Smalltalk. The environment is there and
the GUI stuff is relatively simple. If I had to do a stream-to-stream
program (or anything with a semi-complex data structure), I'd probably stick
with Lisp. In any case, I'd prefer either to Java or C++.
faa