[cltl3-devel] Some other suggestions

[Gustavo]

Hello, everyone,

CL could use a new standard, specially in the area of threads, FFI, sockets,
extensible streams (Gray or Simple streams), Unicode support and perhaps
also MOP. It would be nice to see something like a transaction model for
better thread support. There are also a few ideas that I would like to
share.

One thing is declarations for "static-ness". For instance, suppose that you
have a generic function which you won't add any new methods to and that you
will not change any method of this generic function. So you should be able
to optimize its call by declaring it static. Same thing could be done to a
class (and freeze subtypes / slots), to a type declaration or to a normal
function (don't know if it is usefull to do this to function as I am no
compiler writer). Well, I wouldn't object if this is not standardized, it is
just a simple idea.

The system definition also needs to be standardized. And I would say
something better than ASDF. There is a project called
mudballs<http://mudballs.com/>that has some neat features. How about
making it possible to download
projects in a similar way to how you install software in Linux (you put
addresses of the repositories in a configuration file, then call a function
that downloads and compiles packages)?

Another neat feature: every package having its own readtable, which can be
changed and copied to another package. It would avoid ugly workarounds to
make readmacros portable (like cl-sql uses).
named-readtables<http://common-lisp.net/%7Etrittweiler/darcs/editor-hints/named-readtables/>is
a good example of how this can be done.

I would also like to state that backward compatibility should be taken into
account and thinking not only twice, but at least three or four times before
doing things in an incompatible way. We don't have enough programmers to
rewrite every library that has already been written in CL, and just lose
them all would be a shame.

And last, one thing that could be better in implementations is the hability
to make smaller programs. I believe that ECL is the best implementation when
it comes to RAM usage or to distribute small programs - you can write a
bunch of programs and compile them into small executable which depends on a
pretty much small dynamic library. Implementations that save the lisp image
won't do as good as this for obvious reasons, but, how about separating cl
function into modules (a module for sequence manipulation, another module
for pretty printing, another module with CLOS...) and make those modules
unloadable? This way you can unload unnecessary modules to your program
before dumping the core image. Well, this idea may be a little tricky to be
actually done, so this probably should be left for a distant future, if
ever.

You all can count on me to do some of the coding. And to give some opinion
as well :)

Gustavo.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mailman.common-lisp.net/pipermail/cltl3-devel/attachments/20090516/14ce1585/attachment.html>