Well, no one seemed to respond to my first post, so now I'll try with an
optimized version.
What, if any, are the particular properties of Lisp that make it a good
choice for implementing a standard representation of complex
hierarchical dynamical systems, which may be then evaluated by programs
written in any language?
Thanks,
Lyle
In article <················@cogni.iaf.cnrs-gif.fr>, lyle borg-graham
<····@cogni.iaf.cnrs-gif.fr> wrote:
> What, if any, are the particular properties of Lisp that make it a good
> choice for implementing a standard representation of complex
> hierarchical dynamical systems, which may be then evaluated by programs
> written in any language?
Maybe this is in a direction of an answer:
1) Macros, Macros and Macros (implement your surface syntax easily).
2) S-Expressions and S-Expressions (easy basic representation).
3) Dynamic Objects through CLOS (changeable it to almost whatever
object-system you want).
4) Excellent combination through concepts of FP.
5) "Executable models" through mapping to Lisp
6) zillions of higher-level tools built on top of
Lisp (logic languages, theorem provers, simulation
engines, rule engines, verified implementations, ...).
I don't know if it really helps, but here is a pointer
how Scheme can be used in a field where mathematical
notation mostly makes the subject unclear: ;-)
http://www-swiss.ai.mit.edu/~gjs/6946/index.html
and the draft book SICM (!):
http://www-swiss.ai.mit.edu/~gjs/6946/book.pdf
--
Rainer Joswig, Hamburg, Germany
Email: ·············@corporate-world.lisp.de
Web: http://corporate-world.lisp.de/
* "lyle" == lyle borg-graham <····@cogni.iaf.cnrs-gif.fr> writes:
lyle> Well, no one seemed to respond to my first post, so now I'll
lyle> try with an optimized version.
lyle> What, if any, are the particular properties of Lisp that make
lyle> it a good choice for implementing a standard representation of
lyle> complex hierarchical dynamical systems, which may be then
lyle> evaluated by programs written in any language?
Not sure what do you mean by evaluation in other
languages. Cross-compilation?
Lisp is often used in dynamic applications requiring high degree of
software adaptation on execution stage. Unlike in many other
languages, runtime code modification in Lisp is fairly affordable. For
instance, Sztipanovits, Karsai and Bapty descirbed in [1] the use of
Lisp for signal processing in rapidly changing environment with high
throughput requirements.
Another advantage of Lisp when dealing with complex problems is its
powerful macro system, which allows developer to concentrate on a
problem, rather on how to represent it in code.
--
Eugene Zaikonnikov
1. Sztipanovits J., Karsai G., Bapty T. Self-Adaptive Software For
Signal Processing. CACM, May 1998/Vol.41, No.5
--------------E81E758D813DE2E085E1B6BF
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Eugene Zaikonnikov wrote:
> lyle> What, if any, are the particular properties of Lisp that make
> lyle> it a good choice for implementing a standard representation of
> lyle> complex hierarchical dynamical systems, which may be then
> lyle> evaluated by programs written in any language?
>
> Not sure what do you mean by evaluation in other
> languages. Cross-compilation?
>
> Another advantage of Lisp when dealing with complex problems is its
> powerful macro system, which allows developer to concentrate on a
> problem, rather on how to represent it in code.
Sorry I wasn't clear: I meant evaluation of the dynamical system model
itself. In other words, one might have any number of (software) tools for
the numerical analysis of some complex system model. However, the model
itself must be constructed by referencing some kind of list of parameters
or text (requiring greater or lesser degrees of by-hand translation). So,
is Lisp in particular good for this "generic" description level?
Lyle
--------------E81E758D813DE2E085E1B6BF
Content-Type: text/html; charset=us-ascii
Content-Transfer-Encoding: 7bit
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
Eugene Zaikonnikov wrote:
<blockquote TYPE=CITE>lyle> What, if any, are the particular properties
of Lisp that make
<br>lyle> it a good choice for implementing a standard representation
of
<br>lyle> complex hierarchical dynamical systems, which may be then
<br>lyle> evaluated by programs written in any language?
<p>Not sure what do you mean by evaluation in other
<br>languages. Cross-compilation?
<p>Another advantage of Lisp when dealing with complex problems is its
<br>powerful macro system, which allows developer to concentrate on a
<br>problem, rather on how to represent it in code.</blockquote>
Sorry I wasn't clear: I meant evaluation of the <i>dynamical system
model</i> itself. In other words, one might have any number of (software)
tools for the numerical analysis of some complex system model. However,
the model itself must be constructed by referencing some kind of list of
parameters or text (requiring greater or lesser degrees of by-hand translation).
So, is Lisp in particular good for this "generic" description level?
<p>Lyle</html>
--------------E81E758D813DE2E085E1B6BF--
* "lyle" == lyle borg-graham <····@cogni.iaf.cnrs-gif.fr> writes:
[...]
lyle> Sorry I�wasn't clear: I meant evaluation of the dynamical
lyle> system model itself. In other words, one might have any number
lyle> of (software) tools for the numerical analysis of some complex
lyle> system model. However, the model itself must be constructed by
lyle> referencing some kind of list of parameters or text (requiring
lyle> greater or lesser degrees of by-hand translation). So, is Lisp
lyle> in particular good for this "generic" description level?
Ok, I'll try to summarize:
1) The model is constructed based on some high-level description;
2) Then, the model is simulated employing already existing specific
tools.
For the part (1), Lisp fits perfectly: it is just the ideal language to
describe high-level descriptions. In other words, creation of
domain-specific language describing your problem set (in this case,
model representation) would require substantially less effort than with
'conventional' languages. E.g. if you were simulating electric
circuits, you could define your own syntax denoting parallel and
serial combinations and primitive elements (capacitors, resistors
etc.), and then group them hierarchially. Then your code could look
like this:
;;; Just an illustration; not that this circuit makes any sense.
(defcircuit foo ;; the circuit name
(parallel (capacitor .25 mkf)
(resistor 3 ohm)
(serial (resistor 5 mohm)
(capacitor 1 pf))))
As you see, all implementation details are hidden behind user-defined
artifacts, making data easier to parse both by humans and by other
programs.
The complexity of doing (2) is depends from input formats of the tools
you use. If utility understands s-expressions, then you're lucky. If
not, it is still doable: harder than with sexprs, but not any worse
than if you were using other language.
--
Eugene Zaikonnikov
"Eugene Zaikonnikov" <······@cit.org.by> wrote in message
···················@localhost.localdomain...
> * "lyle" == lyle borg-graham <····@cogni.iaf.cnrs-gif.fr> writes:
>
> [...]
>
> lyle> Sorry I wasn't clear: I meant evaluation of the dynamical
> lyle> system model itself. In other words, one might have any number
> lyle> of (software) tools for the numerical analysis of some complex
> lyle> system model. However, the model itself must be constructed by
> lyle> referencing some kind of list of parameters or text (requiring
> lyle> greater or lesser degrees of by-hand translation). So, is Lisp
> lyle> in particular good for this "generic" description level?
>
> Ok, I'll try to summarize:
> 1) The model is constructed based on some high-level description;
> 2) Then, the model is simulated employing already existing specific
> tools.
>
> For the part (1), Lisp fits perfectly: it is just the ideal language to
> describe high-level descriptions. In other words, creation of
> domain-specific language describing your problem set (in this case,
> model representation) would require substantially less effort than with
> 'conventional' languages. E.g. if you were simulating electric
> circuits, you could define your own syntax denoting parallel and
> serial combinations and primitive elements (capacitors, resistors
> etc.), and then group them hierarchially. Then your code could look
> like this:
>
> ;;; Just an illustration; not that this circuit makes any sense.
> (defcircuit foo ;; the circuit name
> (parallel (capacitor .25 mkf)
> (resistor 3 ohm)
> (serial (resistor 5 mohm)
> (capacitor 1 pf))))
>
In fact, one of the may uses of Lisp machines was writing design tools for
electronics. Symbolics made forays into that area and many companies (most
notably among them AMD) had entire groups devoted to designing electronic
CAE tools using Lisp.
faa
From: Reini Urban
Subject: Re: More focussed question on Lisp and complex systems
Date:
Message-ID: <39b93d76.203181269@judy>
lyle borg-graham wrote:
>Well, no one seemed to respond to my first post, so now I'll try with an
>optimized version.
>
>What, if any, are the particular properties of Lisp that make it a good
>choice for implementing a standard representation of complex
>hierarchical dynamical systems, which may be then evaluated by programs
>written in any language?
lisp is a programming language and not merely a data representation
syntax. you can of course represent complex data with lisp and you can
easily read/write/parse/modify it, but without lisp this argument makes
no sense.
a lot of data is stored in lisp format and processed by e.g. c++, and
doesn't make use of its special advantages.
an argument to take lisp would be the representation of functions in the
data (you said dynamic), or callbacks in a uniform syntax. but then you
also cannot take another language to read this.
or available tools (like emacs) which can handle such data nicely.
but better take XML or any other simplier stuff but fancier stuff.
or take lisp as language to process it.
--
Reini Urban
http://xarch.tu-graz.ac.at/autocad/news/faq/autolisp.html