TypeL is Common Lisp sublanguage with strong typing and type
inference a-la ML. It is first version of TypeL, and it is 
very primitive.  These features are implemented:
  1.  Polymorphic type inference.
  2.  Curring.
  3.  TypeL is Lisp-1.
  4.  Arithmetic, boolean and list operations.

Features that will be implemented in feature releases:
  1.  Algebraic types and pattern matching.
  2.  Detailed error reporting.
  3.  Code optimization based on types.
TypeL is licensed under terms of LLGPL.

SEQUEL (SEQUEnt processing Language) is designed both as a general
purpose AI language for generating type-secure and efficient Lisp 
programs and as a very high level specification language for 
implementing logics on the computer.

Chaosnet was an early networking protocol developed at MIT.  Near as I
can tell it was developed before TCP/IP, perhaps during the early
Arpanet NCP protocol days.  The protocol was supported by Symbolics
lisp machines as a native networking protocol.  Older machines (like
my ancient 3600) don't have TCP/IP support but do support Chaosnet on
Ethernet.  This is a port of some really really old BSD kernel code
to modern day linux.

I doubt anyone would want this code unless they have some old lisp
machines they are playing with...

I've tested this code with General 7.2 and 8.3.  It allows QFILE
transfers back and forth, which was my goal.  I also hacked the RTAPE
server code to do RTAPE support using a disk file instead of a real
file.  This is useful for archiving...

-brad

In hindsight, we had made several major mistakes - mistakes that seem to be repeated again and again throughout the software industry.

Part of the problem was how arrogant we were. We believed that we could spend a couple of days watching trained lawyers perform a highly-skilled job, talk briefly to them, and then make their jobs completely obsolete.

Worse, we made the job completely non-fudgable. In any human process there's always a degree to which the outcome can be fudged by the person performing the task. Even when the rules are simple or well-understood, there are always cases when someone will have a compelling reason to do things differently. In this case we didn't even know all the rules, and discovered to our horror that there were many more edge-cases than we'd imagined.

In this article, we're going to steal an idea from one of the most theft-worthy languages out there: Lisp. We're going to pick out one of its most useful features -- the ability to treat functions as data -- and talk about how to apply this feature, in a slightly different form, in Java.
- Dan Milstein

In its most general form, text editing is the process of taking some input, changing it, and producing some output. Ideally, the desired changes would be made immediately and with no effort required beyond the mere thought of the change. Unfortunately, the ideal case is not yet achievable. We are thus consigned to using tools such as computers to effect our desired changes.

Computers have physical limitations. These limitations include the nature of user-interface devices; CPU performance; memory constraints, both physical and virtual; and disk capacity and transfer speed. Computer programs that perform text editing must operate within these limitations. This book examines those limitations, explores tradeoffs among them and the algorithms that implement specific tradeoffs, and provides general guidance to anyone who wants to understand how to implement a text editor or how to perform editing in general.

I do not present the complete source code to an editor, nor is the source code available on disk (at least from me: see Appendix B). For that matter, you won't even see a completely worked out algorithm. Rather, this book teaches the craft of text editing so that you can understand how to construct your own editor.

How can you track complex information flow for an organization rapidly changing its structure and workflow?

This is the problem we've been facing since we established Square USA Honolulu Studio in 1997 and began to work on a 100% computer-generated feature film. This is a new studio trying to do something new, and things change very quickly and sometimes drastically.

In the film production, the most important thing is to get the final film-out image, and it doesn't matter how you get it. The consistency of workflow is sometimes compromised by the deadline of image delivery. To cope with this situation, we've been using a Lisp-based object oriented database (OODB) from the beginning of the production. Lisp's flexibility allows us to change internal data structures quickly while maintaining the compatibility with the other parts of the production, which turned out to be the key requirement for such a fluid structure.

We implemented a client-server architecture on top of the OODB and defined a query language between them. No matter how the internal definition of schema changed, we could keep the old query interface as well as the new one so that the old client tools would work. Also it allowed our programmers to work in parallel, without making them stop and update their interface all at once.

All language is a set of symbols whose use among its speakers assumes a shared past. How, then, can I translate into words the limitless Aleph, which my floundering mind can scarcely encompass? [...]

Really, what I want to do is impossible, for any listing of an endless series is doomed to be infinitesimal. In that single gigantic instant I saw millions of acts both delightful and awful; not one of them occupied the same point in space, without overlapping or transparency. What my eyes beheld was simultaneous, but what I shall now write down will be successive, because language is successive. Nonetheless, I'll try to recollect what I can. [...]

The Aleph's diameter was probably little more than an inch, but all space was there, actual and undiminished. Each thing (a mirror's face, let us say) was infinite things, since I distinctly saw it from every angle of the universe.

Kocsis is a Young Lisper and he still lives with his parents while attending high school. He booted the Symbolics to show me that everything worked. The entire scene was kind of surreal, because I had all these flashbacks of a time when I was about Kocsis' age, a time when I just started to realize, that programming was a way of life for me. I was entirely to moved emotionally to even touch the keyboard while the machine was still running. Strange.

The way it is now leads to the cleanest and most natural implementation. I have tried both modifications you suggest (collapsing the two IDs into one, using URL params instead of hiearchical segments), and although I agree it's an improvement in the location bar it's a net loss in the code. I'll look again at the URL param change, since a few different people have suggested it, even though it muddies the semantics of the framework internals somewhat (I seriously doubt anyone but me would care). There will probably be two separate IDs for the foreseeable future, however - among other things, it makes session-affinity load balancing possible (with a proxy that knows which sessions are handled by which instance).

As for putting continuation IDs in cookies, no way. I'm not going to present the user with a "preference" that amounts to "do you want to horribly cripple the usability of this application for no real gain?" If you want to hack that in for your apps, go ahead.
-Avi Bryant

The Lisp Machine manual describes both the language and the operating system of the Lisp Machine. The language, a dialect of Lisp called Zetalisp, is completely documented by this manual. The software environment and operating-system-like parts of the system contain many things wich are still in a state of flux. This manual confines itself primarily to the stabler parts of the system. It describes how to program, but not for the most part how to operate the machine. The window system is documented separately in the Lisp Machine Window System manual.

And you're right: we were not out to win over the Lisp programmers; we were after the C++ programmers. We managed to drag a lot of them about halfway to Lisp. Aren't you happy?

--Guy Steele

And I have the ultimate respect for Paul Graham -- I think there's a good probability that in a year or two we will credit him with being the man who solved spam. But I think that if you try to ignore the fact that millions of programmers around the world have learned lisp and don't prefer to use it, you're in the land of morbid cognitive dissonance. And this attitude that "lisp is only for leet programmers so it's good because only l33t programmers will work on our code so our code will be extra good" is just bullshit, I'm sorry. Plenty of brilliant programmers know lisp just fine and still choose other languages. Most of them, in fact.[...]

nd then the lisp defenders would argue that it's theoretically possible to write efficient code in lisp, as long you avoid "cons," which is at the heart of everything that makes lisp a great programming environment. So you get the worst of both worlds: lisp syntax without functional/recursive/list-based programming.[...]

I never said there was anything wrong with having closures in a language. I said that there was something wrong with using closures to maintain state in a web app.
-Joel Spolsky

Bosco is a simple framework for building Cocoa applications using OpenMCL. You'll need OpenMCL 0.14.1 or later. Bosco includes a starter app-wrapper and Lisp source files, and instructions for building and modifying your application.

 Kevin, this is fascinating code. I learned a lot about E from reading it. 
 There's an old saying "You can write FORTRAN in any language." Although much 
 of E's design comes from my reaction to the inflexibility of other systems, 
 reading your code made me realize that I am still coding in habits I've 
 learned over 20 years of programming in those less flexible languages. It's 
 as if I've lived so long without that flexibility that I'd forgotten why I'd 
 wanted it.

 Ted Nelson once explained to me:
 After Edison invented moving pictures, at first people made movies by filming 
 theater. The closeup, the pan, the zoom -- all these had to be invented. 
 Only with the inventions of these patterns did we discover how the new 
 medium wanted to be used. Good style came to be understood only as the 
 possibilities of the new medium were explored.

I also watched the webcast of this years Spam Conference and found some of it inspiring. Interesting how some talks pick up threads that got lost during AI winter. Interesting to see just how successful pure statistical methods can be.

I think that it is very very difficult to learn how to code in LISP
if you have only used PL-1, and that only for 6 months at most 
while getting stiff doses of theory in all your courses at the same
time.  I remember compiler-writing was a concurrent course, and that
they were supposed to write it in the PL-1 variant.  (I took that course,
but later, and I brought my own physicist friends with me, and we
point-blank said that we weren't interested in writing a compiler 
unless we could do so in LISP.  Which the department allowed, in
hindsight I think out of astonishment.)

If this experience is in any way typical of computer science teaching,
no wonder we aren't all using LISP today.  I haven't used LISP in 15 years,
but I still _dream_ in LISP sometime, and this whole thread has 
reminded me how much I miss it.  I got an incredible rush of pleasure, and
_memories_ when I first disovered that in python I could write _this_

         apply(eval('widget.' + d['functionName']),(), d['functionArgs'])

I still dream in LISP sometime.

She also wrote an eloquent text against software patents. A long time ago she also wrote a device driver for monkey brain implants. [1]

I. Introduction -- Physics Patterns
I want to provide a tool or set of tools (tentatively 
called "Physics Patterns") that:
   facilitate the theoretical and computational
   elementary particle Physicist cycle:
   1) proposing a Lagrangian with a "valid" symmetries
   2) deciding the fields and their interactions
   3) writing the action
   4) Evaluating the path integrals with Feynman style 
   propagators/diagrams.
   5) evaluating cross sections (to be compared with experiments)

(The tool now in embryo state is based on:
Lisa: http://lisa.sourceforge.net
JLisa: http://jlisa.sourceforge.net
Maxima: http://maxima.sourceforge.net
MatLisp: http://matlisp.sourceforge.net 
and runs on CMU Lisp. It is an interpreter that parses
a Lagrangian expressed in Maxima language, and some
initial conditions data and then spits formulas 
and numbers back.)

Apocryphal stories of Richard Feynman are told saying that
he was able to compute path integrals in hours that would
take other Physicists days or even months.  Well, this 
tool in a sense, attempts to capture the "mind of Feynman", 
abstract its computational patterns towards Lagrangians 
and the evaluation of path integrals; and put it to 
work in a general context (QED, QCD, Electroweak, Standard Model, 
Gravity, String, Quantum Loop Gravity, etc.)

LISA is a production-rule system implemented in the Common Lisp Object System (CLOS), and is heavily influenced by CLIPS and the Java Expert System Shell (JESS). At its core is a reasoning engine based on an object-oriented implementation of the Rete algorithm, a very efficient mechanism for solving the difficult many-to-many matching problem ("Rete: A Fast Algorithm for the Many Pattern/Many Object Pattern Match Problem", Charles L. Forgy, Artificial Intelligence 19(1982), 17-37.) Intrinsic to LISA is the ability to reason over CLOS objects without imposing special class hierarchy requirements; thus it should be possible to easily augment existing CLOS applications with reasoning capabilities. As LISA is an extension to Common Lisp, the full power of the Lisp environment is always available. LISA-enabled applications should run on any ANSI-compliant Common Lisp platform.

The researchers believe the new evidence shows that "sonofusion" generates nuclear reactions by creating tiny bubbles that implode with tremendous force. Nuclear fusion reactors have historically required large, multibillion-dollar machines, but sonofusion devices might be built for a fraction of that cost.

The research team used a standing ultrasonic wave to help form and then implode the cavitation bubbles of deuterated acetone vapor. The oscillating sound waves caused the bubbles to expand and then violently collapse, creating strong compression shock waves around and inside the bubbles. Moving at about the speed of sound, the internal shock waves impacted at the center of the bubbles causing very high compression and accompanying temperatures of about 100 million Kelvin.

Whereas data from the previous experiment had roughly a one in 100 chance of being attributed to some phenomena other than nuclear fusion, the new, more precise results represent more like a one in a trillion chance of being wrong, Taleyarkhan said.

"There is only one way to produce tritium - through nuclear processes," he said.

The results also agree with mathematical theory and modeling.

"Where are the flying cars? Where are the moon colonies? Where are the Dynabooks and Portable Lisp Machines?"

Linear Page Flow Logic

UnCommon Web provides the illusion that pages are nothing more than function calls. This allows application developers to write the page flow logic as if it was a "regular" sequence of function calls, ignoring the complexities of state management and the HTTP request/response paradigm.

UI Component Library

UnCommon Web's Component Oriented UI system allows the applications UI, both the graphical elements and the presentation logic, to be easy reused and adapted to the application's particular needs. A library of standard components is also provided.

Adaptable

UnCommon Web makes heavy use of classes and generic functions and has been designed with adaptability in mind. Any change you want to make can, probably, be accomplished by defining a generic function and a class or two.

Dynamic HTML

UnCommon Web provides a programmer friendly HTML generation library and a designer friendly HTML templating system.

Support for i18n

UnCommon Web provides support for transparent formatting and parsing of dates and numbers based on the user's locale and a convient mechanism for creating multi-lingual web applications.

Multiple Server Backends

Apache+mod_lisp and portableaserve backends are supported.

Multiple Lisp Implementations

UCW runs on OpenMCL, CMUCL and SBCL.

This is the first posting via Blapp. I can now create content locally on my Powerbook, preview it on the local Apache and publish via the built-in rsync. Very convenient especially for postings that reference images.

I do like blosxom. It's very compact and the plugin system has a good design. Using the file system as document store is a Good Thing(tm). On the other hand I would prefer to eat my own dogfood and use a Common Lisp powered blog software. So I'm taking a look at various projects.

I know it's not Common Lisp, but I've been running a blog engine[1] on PLT Scheme for a few months now. The code is part of the Schematics project, though it's still pretty tied to my setup, I haven't gotten around to making it customizable.

[1] http://www.eighty-twenty.net/blog

His book The Plenitude is available online as PDF and HTML.

Action Groups are groups of action entries that an Emacs user can create, save, name and access quickly. In a general sense these actions are any automation that a user can imagine to help with his activities. The user instantiates these automations as action entries which are a specific instances of some action from the current collection of actions. Actions can be as simple as finding a commonly used file in a buffer, to more complex like executing a previously defined keyboard macro, to very complex like an unimaginable whopper defined by a user created Action Template. Action Templates are an extensibility feature of Action Groups and allows the user to easily create new actions, Agroups supplies a useful predefined collection of actions created with Action Templates.

The Vanilla Lisp Shell (VLS) is designed to provide an Emacs interface to a Lisp process that from the user's perspective works basically the same way for every flavor of Lisp. For example `M-RET' evaluates an expression and `C-c C-b' produces a back-trace regardless of the type of Lisp. VLS will work with any Lisp specification such as Common Lisp or Scheme and any Lisp implementation such as Allegro Common Lisp or CMU Common Lisp.