LEP - Lisp Empowered Program

A Lisp Machine System

What's the design objective of this system?

Lisp Machines were single user workstations, for the intellectual
workers (mainly the programmers) of the early 80's.

Nowadays, computers are much more diverse.  Has a lisp machine any
meaning in an iPhone?  Or in a web/cloud server?

If we consider the lisp programmer workstation, wouldn't it need
"cross" development tools, so that he may deliver executables on
current customers' systems?

A Lisp System

When the GNU project started, it was expected to be written (at least
partially) in lisp.  Notably: "Both C and Lisp will be available as
system programming languages." [Message-ID: <771@mit-eddie.UUCP>].
Nowadays, the only significant part of the GNU system that's using
lisp is GNU emacs.

A lisp implementation for unix system programming

A lisp implementation with detached type tags would need no FFI to
access unix APIs (libc).

A system for lisp system programming

Replacing or wrapping libc with a liblisp would let us do system
programming with a classic lisp implementation.  Plus some
implementation support for things like signals, but that should be
already mostly covered by unix lisp implementations.

Let's just do it

This directory will be filled by lisp system code.

1- Boot a CL implementation as /bin/init on a unix kernel.  cf.

   When Movitz will be advanced enough, we would move to Movitz.

2- implement services, shells, editors, tools, etc, 100% in lisp.

3- temporarily, some tools may be implemented in C, eg. X11 server,
   gcc or clang to compile the linux kernel.  But since the system
   wouldn't contain the usual C libraries set (some exception as
   needed by lisp implementations or lisp programs thru FFI, etc).

4- we may depart from the usual unix file system organization (users,
   groups, etc).  Since we use a unix kernel, we could use those
   unix/posix notions to implement our services, but our services
   don't necessarily need to replicate them.

Note: emacs-on-user-mode-linux is statically linked, and thus it uses
a few C libraries, implicitely.  Similarly a CL implementation would
use C libraries (statically or dynamically).

Building blocks:

- component manager (distribution packages, to install binary
  components (C libraries), and perhaps lisp software (but quicklisp
  would be used for source lisp distribution).  The component manager
  may be built upon the code of quicklisp and asdf (quicklisp
  distributions, tar.gz, asdf dependencies, etc).

  cf. http://nixos.org/nix/

- user interface:

    - editor (Hemlock, or climacs).

    - X11 or frame buffer?

    - CLIM?

    Probably we want a unified user interface, like the architecture
    of emacs, where the system takes charge of the user interface for
    the 'applications' (emacs lisp packages).  But really, it's to
    Cocoa frameworks, etc.

- services

    - http server
    - ftp server
    - ssh server
    - nfs server
    - mail server

    - dns server

    - ddns client/server
      A program to update a dynamic dns with changing IP addresses.

    - dhcp server
    - news server
    - irc server

    - printing server
    - 3dprinting server

- applications

    - http client
    - ftp client
    - ssh & telnet client
    - nfs client
    - mail client
    - news client
    - irc client


- mount -o rw,remount root