Just as a friendly ammendment.... The Interleaf engine is written
in C, I believe, and wrapped with a Lisp interface. They also
provide Lisp access to the wrapping so you can change and extend
the publishing functions.
Yes...
I use it for everything except Internet
stuff, and it's *Genuinely Interesting Software*.
Agreed!
Ok, I'm an enthusiast, I just can't help but chime in here. So I'll
try to amplify on your points in order to justify this post.
[** Disclosure: Until very recently I worked for Interleaf as product
manager for Lisp and the developer's environment, I was user #1 of
Interleaf Lisp, and I am still actively working with Interleaf as
a consultant.]
The Interleaf runtime engine is written in C, including the embedded
Lisp interpreter. Interleaf Lisp is a proprietary dialect that
provides a healthy subset of CommonLisp (about 75% **) plus many (a
few thousands of) extensions for interfacing with the UI and
publishing engine.
[** Some significant incompatibilities exist; for example, code runs
in the interpreter with dynamic scoping, and lexical closures are
not supported at all.]
Most of the UI (menus, preferences) and a lot of the system
functionality (startup, profiles, tools, utilities, key bindings) are
actually written in Lisp. As of the current release (5.3.1), about
80% of the UI "wrapper" is implemented in Lisp. Most standard
dialogue boxes are not. Some parts of the system are customizable
and/or accessible from Lisp even though they are not actually defined
in Lisp.
Users can develop their own applications in Lisp, ranging from simple
scripts to sophisticated layered applications. Some 3rd party
products are built on Interleaf Lisp, including tools for writing,
active links, and database publishing.
The "Developer's Toolkit" is a licensed option; it includes Lisp tools
(listener, debugger, online doc) and source code for the Lisp layers.
The DTK includes an Emacs "foreign lisp" interface so you can work
within Emacs and communicate via TCP/IP with a running Interleaf.
The most powerful feature for developers is the embedded object
system. ** Almost everything within a document is mapped to a Lisp
object: layout frames, paragraphs, charts, boxes and lines.
Applications can define object classes and provide custom methods
(select, open).
[** Interleaf Lisp has a proprietary object system based on message
passing. Think of it as a stripped down Flavors. There are no
fancy features like instance variables.]
In conjunction with active desktop and document objects, the UI can be
customized to create intelligent interfaces, or "active documents".
This is very good stuff indeed; it's an amazing publishing system, and
may be breakthrough technology in its use of Lisp as an extension
language.
--
--- Keith M. Corbett --- Consultant, document systems software
--- 91 Elm Street --- ···@world.std.com
In article <·················@world.std.com> ···@world.std.com (keith m corbett) writes:
[** Interleaf Lisp has a proprietary object system based on message
passing. Think of it as a stripped down Flavors. There are no
fancy features like instance variables.]
Hmmm. Personally I don't think of instnace variables as particularly
fancy. How do these objects maintain state?
In article <····················@win57.nas.nasa.gov> ······@nas.nasa.gov (Eric Raible) writes:
In article <·················@world.std.com> ···@world.std.com (keith m corbett) writes:
[** Interleaf Lisp has a proprietary object system based on message
passing. Think of it as a stripped down Flavors. There are no
fancy features like instance variables.]
Hmmm. Personally I don't think of instnace variables as particularly
fancy.
I agree. I should have quoted "fancy features", as it was
tongue-in-cheek.
ILOS (Interleaf Lisp Object System) is very plain and simple; there is
no high level syntax ("syntactic sugar"), there are no macros on the
level of "defclass" or "defmethod".
If you're interested, here's an example to illustrate the syntax.
(The symbols in the "mid" package are method ids.) This example
illustrates how to run some code before and/or after the user moves
the mouse cursor into the current paragraph:
;; Define a subclass of document component (paragraph)
(defvar my-paragraph-class
(obj-new-class doc-cmpn-class "my paragraph class"))
;; Provide custom method
(defun my-para-mouse-moved-caret (para &rest args)
;; before method here
(apply #'tell-next args) ;this calls the inherited method
;; after method here
)
(tell-class my-paragraph-class mid:provide
mid:mouse-moved-caret #'my-para-mouse-moved-caret)
;; Assign the current component to the new subclass
(tell (doc-point-cmpn) mid:set-class my-paragraph-class)
You also asked:
How do these objects maintain state?
With data plists. System objects maintain their own property lists
using internal methods, and these are not (easily) extensible. But
most objects support application data plists. Most system classes
support transient instance data. Object classes that are associated
with permanent object storage, such as document and desktop
components, support persistent data properties.
For example, on a document component I can save my own data properties
like this:
(tell cmpn mid:put-saved-data 'my-cmpn-id 90703.)
...and later retrieve the data using mid:get-saved-data.
With the existing features in ILOS it is not hard to create a
reasonable high level definition syntax. Indeed, some developers have
rolled their own, but nothing has been adopted formally.
--
--- Keith M. Corbett --- Consultant, document systems software
--- 91 Elm Street --- ···@world.std.com