MCDONLEY%CODSD1@eg.ti.COM ("Alan McDonley%codsd1@eg.ti.com 593-5356", 303) (08/06/87)
This request concerns Ada-Think. I was taught Ada from Booch, "Software
Engineering with Ada". Out of the class I thought I was learning how to
design in Ada. Then I started thinking about what I had learned and it
seems like I learned Ada syntax and Object Oriented Data Representation and
Object Oriented Filing. I knew that I should collect data and procedures
into objects, design interfaces to/from objects, and that I might be able
to simulate opportunism (such as queues and consumers) with tasking.
Now after two years of Ada, Lisp, Art, and C programming I still wonder if
anyone is discussing things like control structures in Ada? Is the only
representation of a state machine a big case or select statement? Is tasking
the only way to get opportunism? I really feel like object oriented design
is just data representation and a method of choosing which file to put
a particular procedure or function into. Such concepts as agendas, behavior
improvement (what I used to call "self modifying code" and now call "learning
systems"), symbolic reasoning, and inference are the kinds of "control
algorithms" that I need to express. I find I do not have any "Ada-Think"
for these, only Lisp, Art, and C-think. Is there a class or book on control
structures in Ada?
I have this basic feeling that Ada is not the correct language for learning
systems. (learning as adjective not verb) Since a learning system ultimately
needs to develop new algorithms but also improve it's behavior over time,
i keep coming to the need for Ada system to write Ada code, send it to the
compiler, relink itself, start the new image, pass a state to the new image,
pass control to the new image, then kill itself. In Lisp (boo, hiss: hacker
language, right?) this concept is very easy to represent, control, and executes
fast because of a built in interpreter, callable compiler, and execution packageconcepts. Example to make up a new procedure, I simply have the system write
the new code and then evaluate it, or if I want blazing speed (Lisp is getting
there), I call the compiler from my system with the new code as a parameter, and then load the new compiled code. The procedure (function) is then available
for use. The call to the compiler and load instructions are each one function
call and there is no need to transfer state and control, or to create new imagesand kill old ones.
This is not a LISP is better than Ada letter. I like Ada. I need to represent
some more complex control algorithms than I ever represented in Pascal. Am
I left to my own resources?
alan mcdonley... mcdonley%codsd1@ti-eg from csnet
mcdonley%codsd1%ti-eg@relay.cs.net from arpa
-------Standard Disclaimer applys until they fire me----can't be long now