LISPOS: My manifesto

[cosc19z5@bayou.uh.edu]

[Snip]

> > If you want the list to serve a purpose you'll need to get several people
> > to agree on doing something, and co-ordinate via the list, or wait until
> > someone who has gone away has a core they consider worthy of being built
> > upon.
> 
> I think we should work in parallel as much as possible.  If some
> people want to work in CL, cool; if some people want to get down to
> the silicon, cool; let them do it.  I wish them good luck, and think
> that (at least the latter) is a fine project (but see points 5,6 of my
> last paragraph).

Alas, I agree.  I was continuously whining about unity and leadership,
and look where it got us?  Nowhere.  Work in parallel.  Find something
that interests you and work on it, and then release it for others
to view and modify (GPL license?).  Maybe one day, somebody will
go web shopping and find all these related, yet separate projects,
and decide to integrate them as hir own little project and we
may have our O/S yet.

Waiting for agreements is not going to work from what I've seen.
I've already started some of my own work.  It's trivial stuff, but
it's a start, and I need it to answer some of my own issues with
my idea of a Common Lisp Shell (a prototype of which is my next
project).

Rodrigo Ventura pointed out a site where you may upload the
fruits of your labor:
	http://www.eval-apply.com/LispOS/

That's where I intend to release anything I do, finished or not,
and if they'll accept notes as a form of work, that's where they
will go.  I encourage everyone to go browsing around there every
so often, and work on something if you feel like it, even if
you are sure your idea won't be taken up.  It could form the
basis for a better, new idea or may provide code that can
be pulled out and integrated into another package.

I intend to stop by there and look around shortly.

Once we have people working all over the place, integration may
eventually happen -- it's our best hope.  At least we'll have the
makings of some kind of foundation -- which is more than what we
have now.

[Snip -- list of things he's working on]

I like it!  You will be posting your results to the web site right?


> Versions of 3,4,6 should be available by late June.  5 will be later
> in the summer, and 7 will be 8-12 months.

And a concrete date!  Bless you man!


> 
> Things I wish other people would do:
> 

[Snip]

> 3) build utilities;

What I'm doing is prototypical, and while it may end up with enough
functionality to be considered a utility, no attention to error
checking or performance has been paid, hence some may regard it
as a toy (and rightfully so).  Still it will be out there and can
be used until it is modified/re-written, or something better
comes along.  I also have possible plans for using it in my
next project (no promises about when/if anything will be done,
things are hectic around here so everything is in question).

For now, everything I see myself doing in the immediate future and
given the direction of this list is prototypes/toys.  They will
provide concrete implementations that can be used, but the only
consideration will be on proving concepts and supplying functionality.

Now, if the focus of the group were narrowed and a unified effort
were brought about -- this might change.

My development is occurring under Win95, and I'm using Harlequin's
FreeLisp.  Some development is occurring on an OSF/1 with a copy
of CMUCL (circa 1994), so anything done in Winblows will be tested
under Unix.  So far I'm sticking to Common Lisp proper, and haven't
moved out of the standard yet.  This will most likely change when
I start on the next project and that's when I'll have to break down
and decide on Unix or Win, or make a concerted effort for some
kind of dual functionality/portability.  That is, if my attention
hasn't been diverted by then.



> 
> 4) help write a free Scheme CLIM (The fact that there's one available
>    for ACL is almost enough to convince me to work with CL instead of
>    Scheme, but then I look at CL and the investment to learn all the
>    libraries and I gag... but if it works for you, cool... regardless,
>    I don't want to argue about it);
> 

I like CL for quite a few reasons.  One feature that I'm finding
particularly useful are keywords.  Apart from allowing one to
name arguments, they also provide the ability to mimic other
syntaxes (please bear with me before you draw any conclusions).
I think this idea was first brought home from this list
or the scheme shell.

For example, a traditional "if-then-else" construct:

	<if> b then
		x
	<else>
		y

Can be used like:
	(<if> b :then
		x
	:<else>
		y)

While this may seem completely contradictory to the goal of making
everything look like Lisp (rather than vice versa), it does come
in handy when "Lisp-isizing" certain non-lisp applications, like
SQL (my current project).

For instance:
	select * from f where condition

Can be modeled in Common Lisp by:
	(select '* :from f :where #'(lambda (x) (condition ...)))

This construct is both familiar to users to Common Lisp, but also
close enough syntactically to the SQL version to be familiar to SQL
users as well.  

On a side note, use of the lambda in the :where adds
some serious power (you now have the ability to format your tables
and perform other side effecting as well as comparison operations
all within the :where, and essentially for free from an
implementation perspective).  This is what I mean by "Lisp-isizing";
re-writing applications to take advantage of useful features of
Lisp (in this case lambda expressions give "where" tremendous
flexibility and power [I believe more so than the original SQL],
and the price is free (CL programmers are familar with it and
should be happy with it, and implementors need do almost nothing
to implement it)).

If applications won't benefit from Lisp-isizing, then IMO, they
should be left alone (until such a time that we end up with a true
O/S rather than a shell).

[Snip]

> 7) applications; applications; applications... 

Lisp-isize what can benefit from doing so, leave the others as is.

Well, that may not be completely true, as one of my ideas for a
Common Lisp Shell would require some measure of cooperation from
the apps.  But whether or not this even sees the light of day
(or dies an unknown death) remains to be seen...


> 
> ../Dave
> 

Regards,
Ahmed