Prism Metaprogramming Tool released

Jim Little
Sun, 24 Oct 1999 19:20:38 -0600

Laurent Martelli wrote:
>   >> Is it real necessary to have these 4 phases ? Why should we
>   >> define integer arithmetics before object orientation ?
>   Jim> Hmm, good question.  The short answer is that new Prism
>   Jim> languages are written with existing Prism languages.  It's
>   Jim> easier to start by creating small building blocks, then using
>   Jim> those to create larger structures.
> Yes, of course. But I'm not sure that integers are required to do
> interesting things, other than arithmetics. I think that sets and
> operations on them are more powerful and more needed. But it's a
> matter of what you want to do.

Hmm... come to think of it, I'm not sure if integer support is necessary
at this time.  I've been trying to think of situations where they would
be necessary, and I can't think of any.  The only situation I can think
of is when you're doing a straight counting loop -- 'for (int i=0; i<3;
i++)' -- and those are actually pretty rare in real programs.  You much
more frequently iterate through a data structure.

But integer arithmetic will be needed at some point, and its a nice easy
task to start out with.

What sorts of operations on sets were you thinking of?  The Prism tool
VM already supports lists and bags and operations on them.

> Sure. I'm just trying to really separate UI from semantics so that in
> the end, semantics do not depend on UI and UI can be changed easily.

That was one of my goals, too.  Prism languages express syntax/UI and
Prism metamodels express semantics.  Thus it's possible to have multiple
languages for one metamodel.

>   Jim> By the way, where can I learn more about OIL?

OIL seems very similar to Prism:

"The goal of this project is to build an open interpretor that will
support Aspect Oriented Programming (AOP). It will also be reflexive in
the sense that we will
reimplement it in itself, so that we can apply AOP's principles to the

The above statement (from your web page) could equally well apply to
Prism, if I understand it correctly.  One thing I'm not clear about:
Prism allows new languages and compilers to be added to the tool at
runtime -- is that also true of OIL?

If my understanding of OIL is correct, how do you plan on tackling the
interoperability ('aspect weaving') issue?  I'm planning on defining
"Interlock metamodels" that will be used to join two disparate models
together.  Also, how does OIL store programs, and how do you write
compilers/translators for those programs?


The Prism Metaprogramming Tool has been released!
Learn more at