Getting Started with Squeak

Joe Davison jwdavison at lucent.com
Wed Sep 30 16:05:14 UTC 1998


Nick Vargish said: 
> 
....
> 
> > and is not well suited to things like creating
> > UIs, building full-blown applications, or other things for which
> > Smalltalk/Squeak are ideally suited.
> 
> There are very few languages well suited to creating UIs. Smalltalk may be
> the only one.
> 
> Perl's actually not bad for full-blown apps. As good as C, if you don't
> mind the fact that it's interpreted (and if you use Smalltalk, you better
> not mind :^).
> 

But don't forget Perl/Tk which allows creating Gui apps.  

As to comparing Perl and Smalltalk, they're definitely aimed differently
and have significantly different look-and-feels.  On unix systems I see two 
kinds of development environments -- What I might call "separable" and
"unitary".  Most C environments are separable, all smalltalks I'm familiar
with are unitary. The separable environments may have be unified with a GUI 
window manager, but the individual components can be run independently, and 
the applications one creates are also independent of the development
environment.  The unitary environments have all the components as part of
the same application/environment, and the applications one create are also
part of that application.  It is possible, generally to create an new
application that runs in a, probably modified, clone of the development
environment/application, but taht takes extra work.

Perl is a separable (and I've only seen it separated) type environment.
Smalltalk, Lisp, Forth, and AP/L are almost always unified.  

Java seems to be in the separable camp.


The unified languages, including smalltalk, seem to be unified in another
way, too, not related to environment -- they tend to have a relatively
simple programming model and syntax -- they're small enough to hold in your 
head and you can reason about how things work without too much effort, once 
you know the basic model.  I'd put Java in this camp, and probably the
languages, such as C and Pascal, for which one can write a fairly simple
grammer.  

Some of the others, Perl included, are much more "ad hoc" -- they just grew
-- and are much harder to hold in your head, because there are lots of
special cases.   Perl, Tcl, and C++ I'd put in this pile.


If you're going to be doing something for which regular expression string
matching would be useful, I doubt you can beat Perl -- I've not used Icon
recently, so it's possible it would be a contender for pattern matching in
strings, but I'm not sure.

Speaking of regular expressions, Has anyone built what they think is a nice
regular expression capability into any OO system?  How did you fit them
into objects?  I built Regex and Matcher classes in C++.  I tend to think
of the Matcher as a ReadStream on a String.  The Matcher has a Regex, which
encapsulates the knowledge of how to compile and execute regular
expressions.  The Matcher uses the Regex whenever the "nextMatch" method is 
called?

joe





More information about the Squeak-dev mailing list