[self-interest] prototypes, "meta" and reflective programming

Albertina Lourenci lourenci at lsi.usp.br
Sat Jan 13 20:23:41 UTC 2001

Dru Nelson wrote:

> >   (|slot1 = foo. slot2 = bar| code)
> >
> > is a form of lightweight meta-programming?
> what is meta-programming?

As far as I know this discussion about metaprogramming
started with my suggestion to search for more integrated
or unifying methods in computer science. Then Brian Rice
suggested we should look for the Tunes project, which tries
to reach this ideal.
There I found the interesting paper by Faré (member of
the Tunes project) about
Metaprogramming and free availability of sources
He says that central to any process of building software
is manipulation of the source code of programs. To
enhance these processes, to ease the task of the
programmer, is to relieve the programmer from all
repetitive and conceptually redundant operations,
so that he may focus on the essence of programming
that is on the problems that have never been solved
yet. This means manipulation of code must be automated
as much as possible, by having machines handle reliably
all the inferior tasks that do not pose theoretical
problems anymore. And to automate programming
is by definiton metaprogramming.
He sees metaprogramming and open development as
two faces of the phenomenon that unifies both of them
called reflective programming.

It seems this story starts with the highly interactive,
integrated and incremental programming environments
of many Lisp systems, such as Interlisp. They are in many
aspects much more advanced than most environments
for development of production software.
So Lisp is an excellent  language for writing metaprograms
i.e., programs that manipulate other programs, such as
programming environments.
So Lisp developed the exploratory programming style.
However Ole Madsen and Claus Norgaard say Lisp is
not considered an alternative for development  of
production programs.

The need for metaprogramming was felt by the
Mjolner Beta group (Aarhus, Denmark).The need
for building large and complex software systems
resulted in the development of more powerful
programming languages and more powerful program
development tools (editors, compilers, debuggers
configuration management tools, user interface tools

The development tools are used for manipulating different
types of information (e.g. program text, run-time
structures, etc)  In order to fulfill the goals of the tool
it must be able to represent this information in a form
that makes the different manipulations possible.
These development tools are often individual tools
with disjoint representations even in the case where
the tools are manipulating essentially the same
information( compiler and interpreter for example).These
problems gave rise to research into architectures for
software development environments.

separate tools with disjoint representantions
pipeline architectures
residential architectures
bus architecture
client-server architectures
common representation architectures.

So the Mjolner Beta system can be characterized
as the usage of abstract syntax trees (ASTs)as the
central structure for handling program information.

The experience with using an object oriented
framework for modeling AST permits building tools
applicable for all programming languages and
more language specific tools to use the same

Could someone trace back when and how
reflection was introduced? Is indeed
reflection a kind of metaprogramming?

Now the connection with virtual machine.

Ungar et al  argues that that a Self-like
in nature  implementation substrate could
support the implementation of a wide variety
of OO languages.They add further that
static compilation techniques became sufficiently
well advanced that code generators could be
produced which supported a broad spectrum
of conventional languages. Many production
compilers have back-end systems which
produce code for C, C++, FORTRAN, Pascal
and similar languages. Perhaps
a Self-like system could form the basis
for a general dynamic compilation system
for a variety of OO languages.

Better there should be a processor for
Self, preferably user-programmable
to add flexibility to the processor's
instruction set.

Why is a user interface a virtual machine
at least some say this?

Above all what 's the role of reflection?

What's the role of pattern-based

Why do things evolved differently
from the original architectures stated
Why are they better?
Joergen Lindskow Knudsen states
clearly the differences among them.

Nice weekend


> Dru Nelson
> San Mateo, California

| Albertina Lourenci                                       |
| PhD  in Architecture and Urbanism                        |
| post-doctorate researcher                                |
| Laboratory of Integrated Systems University of Sao Paulo |
| Avenida Professor Luciano Gualberto, 158 Travessa 3      |
| CEP: 05508-900                                           |
| Sao Paulo Sao Paulo State Brazil                         |
| Voice: +55 011 818 5254                                  |
| Fax: +55 11 211 4574                                     |

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.selflanguage.org/pipermail/self-interest/attachments/20010113/9bea8f3f/attachment.html>

More information about the Self-interest mailing list