[Prev][Next][Index][Thread]

Re: Java / Java on the Mac in January / JavaScript

>Have a look at some of the lisp pointers on the references page for the server.
>They can take you through much of the history and issues.

Or see "Symbolics Technical Summary, Overview, 1985" at URL
http://www.lavielle.com/~joswig/symbolic-computing.html
to get an impression what some people used to have in 1985.

>At least, Java is not Perl.

Recently Larry Wall posted some article to Usenet where he claimed that
PERL is the most fun of all programming languages. ;-)

>>One of the things I'm programming in Lisp is an agent that can work like 
>>Eliza and store like Boris Katz's START system. Would Katz's START system 
>>be workable through Java like it is through CL-HTTP? (Assuming you have 
>>tried the START system.)
>
>Yea, I have written my own natural language system. See my home page. No chance
>that it will be rewritten in Java.  Here, we are looking forward for major qualitative
>advances in technology.  That means, programming environments better than the Lisp
>machine -- and that is 1980 technology. Most of what everyone else is using is 1960s
>technology. We are only four years from the twenty first century.
>
>I guess one can say that Java gives garbage collection to the masses. But,
>it is hard enough to program sophisticated applications in Lisp.  Current java is many steps
>backward from lisp or scheme.  

Yep, interesting projects seem to happen on the Scheme side, too. Just
look at what the GNU people want to do with GUILE (the mother of all scripting
languages ;-) http://www.cygnus.com/library/ctr/guile.html) -> GROW
(GNU Remote Operations Web, http://www.cygnus.com/~tiemann/grow/).

Exerpt:

>Executive Summary
>
>The characteristic GROW application (under construction today) is a special Web browser that can download extensions on
>the fly in order to present new kinds of documents. But GROW offers much more than the ability to create and share active
>Web documents: it is a freely available toolkit that can be linked into virtually any program, thereby providing clean, robust
>interfaces for extensibility in a machine-independent way. 
>
>GROW is fundamentally a scripting architecture, augmented by libraries that provide machine-independent interfaces to
>network (and Internet) services, host O/S services (such as file and directory services), host graphics and sound capabilities
>(and other common performance-critical services). GROW also includes a module system and support for "safe" execution
>so that additional functionality can be added via scripts instead of platform-specific C or C++ code. 
>
>Using the GROW libraries, developers can build custom Web servers and clients or build Web-related capabilities into
>existing applications. Developers can make programs that are able to download extensions and upgrades over the net. The
>programmability of GROW means that applications with GROW linked in can be reconfigured and enhanced in-the-field by
>any programmer. This kind of extensibility makes a network-capable program useful to more people and in more situations.
>It encourages users to find new ways to put the program to work.
>
 
end exerpt

>the useful thing about it is that you can tell the client what to do.  A Scheme or Lisp
>plug-in to Netscape on all platforms would be a better target, but you work with what
>everyone has got.


OpenDoc /CyberDog
-----------------
An interesting contender to may be Apple's upcoming OpenDoc-based
CyberDog architecture. CyberDog is a collection of OpenDoc parts
for Internet access. This architecture may attract a lot of
software authors, since it enables them to build small parts - instead
of bulky and complicated applications. I would expected to see
many free or shareware parts. Some of the Mac developers currently
maintaing the nice Mac clients seem realize the potential and
give CyberDog high ratings.

Just a hint to a long term strategy - the OpenDoc stuff has great potential
(you can develop for it today, its cross plattform, it is no vaporware).
If Lisp vendors want to stay connected to industry trends and technologies
(like: Internet, interoperable objects, component software, ...) they better
hurry up.

What I like about CL-HTTP most, is that it is in some respects on
the front of server software (document generation, server scripting,
OO architecture, free with source (!!!)). Don't stay in the Lisp ghetto.
Making your applications web-aware is certainly one way to go.

Java
----
I see this Java stuff as a kind of Web-Postscript. Few people program
using Postscript, despite SUN's attempt with NeWS - one of Gosling's
projects ;-) (an interesting lesson to learn here - the rest of the
industry didn't want another quasi standard from SUN). But your printer
and maybe your windows systems uses PostScript - programs are generating
postscript as one way to display output.


CLIM and the Web
----------------
Interestingly enough there is some nice stuff we *could* use as a **general**
base for user interface programming -> CLIM (see also the CWEST posting).
Despite all attempts on not marketing it, CLIM is still
alive. CLIM has great potential, but has been used by much to few people
(due to constrains on availability on certain platforms, price, performance,
educational material, free implementation, source code, etc.). It would
be a worthwile project to investigate the possibility of some kind of
a new "backend" for CLIM to generate Web interfaces. This may
require some help from the browser (for doing presentation computation
in the browser, etc.). An ideal CLIM application should need very little
platform specific Lisp code to make interfaces and/or output generation
using X/Motif, Windows, Mac, Lispm, PostScript and HTTP/HTML/Java easily
portable. This would have to include the application framework stuff (menus,
commands, panes, event handling, ...). Does any Lisp vendor see the potential
here? Having a high-level expressing interface manager which could
be extended to support the Web? The Lisp community could need some
new cool areas to show its abilities.

It would be nice if some University projects with support from the CLIM-vendors
(Symbolics, Harlequin, Franz, ...) could advance the state on the art.

I'd rather use tools like Common Lisp, CL-based development environments,
CLIM, CL-HTTP, etc to be productive. Life is short enough.

Greetings,

Rainer Joswig

Rainer Joswig, Lavielle EDV Systemberatung GmbH & Co, Lotharstrasse 2ab, D22041
Hamburg, Tel: +49 40 65808-0, Fax: +49 40 65808-202, Email:joswig@lavielle.com,
WWW: http://www.lavielle.com/~joswig/ , Tel. (priv): +49 40 7355522