Re: Scheme acceptance [no flames]

[Paul Fernhout <pdfernhout@kurtz-fernhout.com>]

Leo Razoumov wrote:
> 
> Gentlemen,
> I spent last weekend learning Python just for the sake of it. There is so much
> hype around Python these days, so I decided to see it for myself.
> 
> In short it looks as a "poor man's Scheme" with some nice syntax cover.
> 
> [Snip]
> 
> The sad point which I would like to make: if Scheme, in its present form, could
> not take off since 1976 it will never do. Something on the syntax or/and
> semantics side has to be done so that all the efforts in designing and
> implementing great language are not wasted.

In another post I gave an example of indentational syntax which works
with DrScheme.

Here is my own two cents on the issue of making PLT Scheme more popular 
amidst a large audience. 

When I was about four years old in kindergarten (at a place which also
had a pre-school) I and a couple other kids discovered you could take a
sort of independent ladder used as monkey bars, remove it from the
monkey-bar supports, and lean it against a big tree to climb into the
tree. We were pulled aside by an aide and told we shouldn't do that
because while it might be OK for us, younger (pre-school) kids might see
it done and duplicate the action and get hurt. [Obviously she may have
been lying and thought it was not OK for me or my friends either.]

Sadly, I think the same story haunts my programming career. I learned
cool things doing stuff like machine code and Lisp (and Smalltalk) yet
am professionally using things like C++ and Java/XML because basically
the sentiment is "other people" might get hurt (confused) by using more
powerful (flexible) systems, and so we all need to use compile time type
checking and named end list delimiter tags and Algol-like syntax and
lots of other junk. Thus, C++, Java, and XML
rule the day. [And yes, you still can shoot yourself in the foot with
any of those -- but the look safer at first glance.]

While I am all for standards, it is a bit sad to see something like
Java/XML becoming so popular as a standard when taken together the
combination is basically a dumbed down Lisp/Scheme. [I'm not saying on a
practical basis there is no value in using Java/XML given the way they
have grown -- just that Lisp or Scheme could have filled those niches a
decade sooner with more technical elegance.] So too, Python is a dumbed
down Scheme in some ways as you describe. Yet, Java/XML does somehow
cater to those who for whatever reasons have difficulties (initially or
permanently) handling lots of abstraction. To an extent Python may do
this as well (although fortunately Python doesn't have compile time type
declarations]. 

Python succeeds because as a whole it does quite a few things fairly
well, covering most things that most people want to do. It has by now a
lot of libraries and several cool applications (especially Zope). The
Python development philosophy strikes a nice balance of saying code
something in Python first, and then optimize things in C if you need to
and link them in.

One way then to let Scheme play on the same field is to add so many
features to it as modules (not to the language) so as to make it easy
for people less capable of handling abstraction to still do most common
things without thinking too much. Then the rest of us won't be stuck
living with dumbed down systems. So, here is some ideas on how to put
even more training wheels on PLT Scheme without compromising the core
integrity of it.

DOCUMENTATION

A tutorial and more examples all shipping with the core distribution.

KILLER APP

Ship a serious business/educational app that people want to use. 
Like a nifty email application system (building perhaps on the 
one already included with more GUI stuff). 
Or something that does stuff with XML.
Or a cool information manager. (That's what I want to do with it).
This killer app provides both a proof of concept and an example.

EASE OF USE

I do think there is some merit to the main point of this thread. 
I think a few simple iterations similar to python in syntax would be
nice
as in:
  (for-in-do x mylist1 
    (print x)
    (for-in-do y mylist2 
      (print y)
      (print (* x y)))
The point is simply to make this easy for a beginner to do. 
Then show them how much better more general mapping options can be.

I would like to see a simple distribution for text and XML and XSL 
processing which included network support and little else. 
Something easy and lite to install on anyone's machine.

I would like to see slightly better support for shipping applications
which use a subset of the system features -- but I expect the new 
development directions will be able to support this. It's fairly easy
as it is to make a DrScheme exe with an embedded app -- but it's a bit
big.
(This isn't as high on my priority list because what is there will
work.)

Better support for files. Have real files a part of the default system.
These should do all the typical file stuff (open, close, flush, read,
write,
set permissions). I had to write an external module to get some of this.
A system that doesn't do all the usual file things easily is difficult
for an experienced programmer to accept as a serious tool.

MAINTAINABILITY 

[This is important to me as a user thinking of shipping an app in the
system].

The underlying infrastructure DrScheme could be more modular 
and am pleased to see that concept is part of the new development
direction.
wxWindows source complexity can be really intimidating.

All license issues should be clear for underlying code like wxWindows or
contributed third-party code. 

I would like to see more of the system written in Scheme as opposed to
C,
perhaps using a translator to C approach as Squeak uses for translating
Smalltalk to C (called Slang). This is a completely new direction.

I would like to see the system support the Squeak platform independence 
approach of emulated widgets. Potentially, PLT Scheme could then
leverage
off of much of the effort done to port Squeak to many platforms by being
low level API compatible (as in use the same calls to blit something 
to the screen or play a sound.) The only problem is that some of
Squeak's 
object model is built into the lowest level API. 

Most of all (after world peace) I'd love to see the various maintainers
of open source languages get together and have a common core. While I
would be suspicious of anything Microsoft actually puts out, the idea of
a common language runtime is in general a good one, or at the very
least, the idea of cross-platform common language support functions, on
which various efficient cross-platform language-specific runtimes could
then be easily built.

OBJECT DEVELOPMENT SUPPORT

This is a language issue: coming from a Smalltalk background, at some
point I find the extra awkwardness of method calls instead of function 
calls distracting. I don't think this can be improved much, short of 
working at a completely higher level where the compiler is modified 
to expect a syntax of (object message args) or 
(object key: arg1 word: arg2) or something else approaching 
the Smalltalk style. Still one can probably do something.

Of course, there is an issue is optimization of the VM for handling
objects
and the implications for garbage collections etc.
On the other hand Scheme is potentially much faster than Smalltalk
and can more easily support optimization using type hints.

I would like to see even better integrated development tools, based on
seeing the unit of development as more of objects/prototypes/classes 
as opposed to files. Integrated source control woudl be nice as well.

OTHER THINGS

I would love to see PLT Scheme become the new Guile.

I would love to see an interface for building and calling native code in
memory.

I would like to see easier integration of newer language modules -- 
but again I see this is part of the plan for the next release (bravo!)
I've made the indentational stuff available before to the list under
an X/MIT license, so feel free to integrate it into that version as 
test case. Obviously, one could then add Python->Scheme or Java->Scheme
or Perl->Scheme or Smalltalk->Scheme translation layers as well.

I'd second the number crunching request. I think the future of
educational
computing is educational simulations -- and those usually take
serious number crunching if they are complex enough to be interesting
(like our GPL'd garden simulator).

DISCLAIMER

PLT Scheme is obviously a fantastic project and is
already succeeding in the core area of education. 
These comments are for broadening out into large fields 
(business / home use).

-Paul Fernhout
Kurtz-Fernhout Software 
=========================================================
Developers of custom software and educational simulations
Creators of the Garden with Insight(TM) garden simulator
http://www.kurtz-fernhout.com