Dolphin portability to GNU Smalltalk and Squeak

Looking through Object Art's Wiki, I noticed that they are heavily
geared towards Windows, but have considered using WINE as means of
running the Dolphin VM under Linux:

http://www.object-arts.co.uk/wiki/html/Dolphin/OtherOperatingSystems.htm

(Note:  The links to the Wiki and FAQ at OA's support page
http://www.object-arts.com/Support.htm are broken).

I wonder though if OA would consider portability in other ways.  There
are 2 other applications of Smalltalk that I would be very interested
in:

1) Source-level portability to GNU Smalltalk & Squeak

The reason for this is because I'm coming to enjoy Smalltalk
development, and would like to use Smalltalk for other tasks,
including what I have heretofore been using Ruby for, namely
scripting.

Others have mentioned that Smalltalk would make a fine scripting
language, were it not for having to start up the VM and run an image.
Since GNU Smalltalk is file-based rather than image-based it would be
well suited as a scripting language.  Unfortunately, GNU Smalltalk
does not come with the highly productive development environment that
one finds in the usual Smalltalk implementations such as Dolphin, so
one way to overcome this is to leverage off the strength of
development environments such as Dolphin by writing the script in
Dolphin, then exporting the source in chunk format for use as a script
in GNU smalltalk.

Since I am still learning Smalltalk, I have not investigated GNU
Smalltalk any further to determine what other changes have to made to
any Dolphin exported code (besides defining stdin, stdout, and
stderr).  If some tweaks to the exported source are required, would
Dolphin consider providing a GNU Smalltalk compatibility mode to
generate scripts?

The reason why I raise this is because I find programming in Dolphin
so much more pleasant than typing in an editor and re-running the
script several times under Linux until it gets fully debugged.  There
has got to be a better way to develop scripting programs, and I think
Smalltalk is it.

For porting entire applications, how difficult is it to migrate from
Dolphin to Squeak?  What possible pitfalls might arise if one writes
using only domain code?  Is Dolphin fully ANSI-compliant?  Squeak
evidently is not, though it comes very close.

2) Running under Linux

One type of application that I would certainly like to run under Linux
involves web applications.  I've noticed that Spray is available for
Dolphin running on Windows.  For various reasons, though, I am much
more partial to running web servers under Linux or FreeBSD rather than
on Windows.  One solution of course is to write it in Squeak and take
advantage of the available Comanche or Seaside packages.  However, I
have not gotten accustomed to Squeak's primitve UI, which is why I
started learning Smalltalk on Dolphin.  Now that I have gotten to like
Dolphin, I would definitely use it to write Windows applications, but
for web applications, Linux (and free software) still beckons.

If I continue to use Dolphin, my only recourse in porting the code to
Linux is via source-level portability, hoping that code from Dolphin
can be imported into Squeak without major difficulties.  Alternately,
would OA consider developing a limited VM for Linux?

Rather than go through WINE emulation of Windows to run
Dolphin-developed applications, how about developing a VM specifically
designed for running web applications?  One can strip the image of all
GUI and ActiveX related code, leaving only domain code so that the
resulting image can be shipped to a Linux box and run under a Dolphin
VM for Linux.  Again, the great development environment need only be
available under Windows, but perhaps a limited run-time environment
can be provided for Linux.

Is this something OA would consider?

Damon

Damon wrote:
If you want to move code back and forth between dialects, I suggest you
check out Rosetta (http://RosettaST.sourceforge.net). It was designed
with cross-dialect code interchange in mind. There's an exporter for
Dolphin available, although I rarely use it myself - I seem to be moving
a lot more code INTO Dolphin than out of it ;-). You can definitely
convert code over to GNU and Squeak - we used Rosetta for the last SUnit
ports.

Cheers

--
--
Joseph Pelrine [ | ]
MetaProg GmbH
Email: [hidden email]
Web:   http://www.metaprog.com

"If you don't live on the edge, you're taking up too much space" -
Doug Robinson


--
--
Joseph Pelrine [ | ]
MetaProg GmbH
Email: [hidden email]
Web:   http://www.metaprog.com

"If you don't live on the edge, you're taking up too much space" -
Doug Robinson

Damon,

> For porting entire applications, how difficult is it to migrate from
> Dolphin to Squeak?  What possible pitfalls might arise if one writes
> using only domain code?  Is Dolphin fully ANSI-compliant?  Squeak
> evidently is not, though it comes very close.

My biggest compaint with Squeak is that its streams to do signal errors on
exhaustion.  Dolphin and Squeak use #displayOn: (or maybe it's a related
selector??) in very different ways.


Morphic is an excellent simulation environment - I just wish somebody would
use it to simulate a reasonable GUI framework  :)   Actually, there is some
promising stuff available.   IMHO, Squeak has a much bigger problem with
"feel" (which is cumbersome out of the box) than it does with "look" (which
has improved a lot in the past couple of year, even as delivered).  The
shrinking selection change set is a must.  Very recently, somebody posted a
few lines of code to (gasp<g>) give us some of the keyboard shortcuts we've
spent years learning.

Take a look at Zurgle.  Ok, I would have not chosen the XP look, though I
can find it ugly and impressive at the same time.  One problem: Zurgle is
bordering on overkill.  There are some other efforts that appear to be
lighter weight; in particlar, look for the gradient fill and icon updates to
menus, and associated system window updates.  There is another project to
use skins from other projects; whether it will catch on I can't say.

I think it's just a matter of time before a good end-user GUI framework
appears for Squeak.  Note that the IDE could remain as as-is.


> Now that I have gotten to like
> Dolphin, I would definitely use it to write Windows applications, but
> for web applications, Linux (and free software) still beckons.
>
> If I continue to use Dolphin, my only recourse in porting the code to
> Linux is via source-level portability, hoping that code from Dolphin
> can be imported into Squeak without major difficulties.  Alternately,
> would OA consider developing a limited VM for Linux?

I'm all for it.  An OA Smalltalk targeted at Linux would be quite welcome.


> Rather than go through WINE emulation of Windows to run
> Dolphin-developed applications, how about developing a VM specifically
> designed for running web applications?

Sounds too limited to me.  If OA were to create a new VM, it probably should
be one that runs on Linux and just happens to be able to support web apps
too.  Also, there is Smallscript to consider.


> One can strip the image of all
> GUI and ActiveX related code, leaving only domain code so that the
> resulting image can be shipped to a Linux box and run under a Dolphin
> VM for Linux.  Again, the great development environment need only be
> available under Windows, but perhaps a limited run-time environment
> can be provided for Linux.

One problem: the details of the Windows API are unlikely to be supported on
another OS.  The Smalltalk code for collections, etc., and the model and
presenter classes would be useful, but the views would have to go.  Also,
Dolphin's strong reliance on external interfacing (which it does very well),
could be problematic in a port to Linux.  Put another way, Squeak uses its
VM as a portability layer, Dolphin does not.

Have a good one,

Bill

--
Wilhelm K. Schwab, Ph.D.
[hidden email]

"Bill Schwab" <[hidden email]> wrote in message

Thanks Bill, I'll take a look at Zurgle.  I recently checked out
Squeak 3.5 again, and now that I'm more familiar with the standard
components of a Smalltalk environmnet, Squeak doesn't seem as
bewildering as it appeared first glance.  When I initally started up
Squeak, I couldn't tell what was going on.

Joseph Pelrine <[hidden email]> wrote in message

> If you want to move code back and forth between dialects, I suggest you
> check out Rosetta (http://RosettaST.sourceforge.net). It was designed
> with cross-dialect code interchange in mind. There's an exporter for
> Dolphin available, although I rarely use it myself - I seem to be moving
> a lot more code INTO Dolphin than out of it ;-). You can definitely
> convert code over to GNU and Squeak - we used Rosetta for the last SUnit
> ports.
>

Thanks Joseph.  This looks fascinating.  It looks like a real solution
for source-level portability.  I'm glad somebody came up with this.

Damon