A while ago I asked about examples of applications that take advantage
of the lisp MOP. At the time the only example I was given one example
of such a program, a DB library that uses reflection to translate
classes into tables, queries etc. ( sorry if I am slightly off on
this, but the message is expired and I am offline ).
I found this to be a bit disappointing because this particular example
could be written in Java as a library for Java using the reflection
api. I didn't expect to get all of the MOP calls in but I expected to
see something that required MOP capabilities available only in lisp
(* and possibly research projects like openJava and openC++ ).
I also expected to see something that was more of a full application,
rather than a library ( libraries are skewed in the sense that they
are used by the same language ). I mention this because I don't want
to confuse that question with my present question.( I am still
looking for such an example if someone has one, but I am looking for
something different here).
I have known lisp on and off for twenty five years. Initially I was
interested because it was the language used for algebraic manipulation
( eg Reduce ). After a while I had heard that lisp was a language that
you could be more productive in, but never really have seen it.
Most recently I've seen it mentioned Paul Graham's paper.
I feel that there are good reasons to believe this statement.
After all a lot of computer language concepts originated or at
least flourished in lisp. At the same time I've seen programmers
say the same thing about their pet language, even VB programmers.
And from what I've seen there are no capabilities in lisp that are not
available in most other languages ( other than MOP, and I do not
believe that that is what is refered to in for example Graham's paper.
In fact I think you see sort of a slow down in production of code when
you use MOP the tradeoff is that it allows you to do things you might
not otherwise do. ) Of course many lispers may not realize that these
capabilities are present in other languages, because programmers in
other languages don't know their own languages very well. About 99.99%
of C++ programmers don't know any thing about C++- beyond the core
language and a smattering of the STL. I suspect that a similar
percentage think that writing a template is something special,
that they should do around once a year. I suspect that about 50%
think the same thing about a class. I also suspect that 99.99% of
Java programmers have never heard of the the reflection API,
and that 99.99% of Python programmers have never heard of
introspection.
We could debate language features, and fall into a language war.
I don't think that will be productive.
I think the best way would be for me to actually examine the source of
a general purpose application and see how lisp is more productive.
Does anyone know of any such application?
Emacs is out because I want to examine the code, modify the code and
walk through the code with a debugger. Frankly while emacs is good for
debugging, I don't think it is very good as a lisp development
enviroment.
Some might suggest RG, but ( aside from the fact that the source is
not available, I already asked ) a main component in RG is a piece
that examines some of the code and does a dataflow analysis. What
I would like to see is a general app that could be ( and often is )
written in a generic language. When is the last time you saw a
generic app with a dataflow analysis piece.
Can anyone make any suggestions?
On Mon, 07 May 2001 07:57:53 GMT, ······@interaccess.com (Thaddeus L
Olczyk) wrote:
> A while ago I asked about examples of applications that take advantage
> of the lisp MOP. At the time the only example I was given one example
[...]
> to confuse that question with my present question.( I am still
> looking for such an example if someone has one, but I am looking for
Here are a couple of recent papers discussing applications of the MOP:
"NetCLOS and Parallel Abstractions - Actor and Structure Oriented
Programming on Workstation Clusters with Common Lisp"
Lothar Hotz and Michael Trowe
Proceedings of the European Lisp User Group Meeting '99
Abstract:
In this paper, we describe an extension of Common Lisp which allows the
definition of parallel programs within that functional and
object-oriented language. In particular, the extensions are the
introducing of active objects, sending synchronous and asynchronous
messages between them, automatic and manual distribution of active
objects to object spaces, and transparent object managing. With these
extensions, object-oriented parallel programming on a workstation cluster
using different Common Lisp images is possible. These concepts are
implemented as an extension of Allegro Common Lisp subsumed by the name
NetCLOS. Furthermore, it is shown how NetCLOS can be used to realize
parallel abstractions for implementing parallel AI methods at a highly
abstract level.
"COSI: Adding Constraints to the object-oriented paradigm"
Gary Curtis, Mark Giuliano
Proceedings of the Lisp User Group Meeting '99
Space Telescope Science Institute
Abstract:
Trans is a Lisp system at the Space Telescope Science Institute (STScI)
which is a key part of the proposal preparation ground system for the
Hubble Space Telescope (HST). It was originally developed in the late
'80s using a mixture of procedural, and blackboard architectures. While
the original application met its requirements and performed well for a
number of years, the increasing complexity of the system and its changing
role meant that it eventually needed to be re engineered.
In developing a replacement we wanted a mechanism to manage the complex
inter-dependencies between application objects in a dynamic system. To
meet this need we developed the Constraint Sequencing Infrastructure
(COSI) which supports a model of programming with methods as constraints.
COSI automatically tracks dependencies between object state and
constraints, manages the relationships between objects, and executes
constraints when necessary to ensure that the internal state of the
system is consistent.
COSI is implemented as a general purpose extension to CLOS via the
Metaobject Protocol (MOP). It extends the object-oriented paradigm to add
the notion of methods as constraints which can automatically rerun when
their inputs change.
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/
The Computer-Aided-Parts-Estimation (CAPE) application used by Ford of
Europe to carefully estimate the costs of parts that Ford designs and then
pays outside suppliers to produce is an extremely sophisticated app that
uses the MOP to attach various things to objects not normally available in
CLOS. See
Cunningham, A. and Smart, R., CAPE,
Computer Aided Parts Estimation, in proceedings of Innovative
Applications in Artificial Intelligence, conference, AAAI Press (1993)
Jeff
"Thaddeus L Olczyk" <······@interaccess.com> wrote in message
······················@nntp.interaccess.com...
> A while ago I asked about examples of applications that take advantage
> of the lisp MOP.
> The Computer-Aided-Parts-Estimation (CAPE) application used by Ford of
> Europe to carefully estimate the costs of parts that Ford designs and then
> pays outside suppliers to produce is an extremely sophisticated app [...]
Is it known who wrote it?
-- O.L.
In article <········@news.core.genedata.com>, Olivier Lefevre
<···············@genedata.com> writes
>> The Computer-Aided-Parts-Estimation (CAPE) application used by Ford of
>> Europe to carefully estimate the costs of parts that Ford designs and then
>> pays outside suppliers to produce is an extremely sophisticated app [...]
>
>Is it known who wrote it?
>
>-- O.L.
>
>
It was/is a Ford in-house system, developed by a collaboration of Ford
staff and consultants (originally provided by Inference). The original
system used the ART expert system shell, but (I believe) that proved to
be too slow for what was being done, and so most of the program was
developed in Lucid Lisp (which was what ART was delivered on at the
time).
The ART windowing code was the last element of the system that relied on
any ART functionality.
Geoff Grief was (as I understand it) one of the original
architects/implementors of CAPE, and Adam Cunningham and R. Smart
(the authors of the referenced papers) were also early
architects/implementors. Adam was a Ford employee, I don't know about
the other author. They had all left the project before I joined it.
BTW, the system is now running under Windows as a LispWorks dll running
behind a VB GUI, talking to an Oracle database using the native Oracle
libraries.