pepsi? coke? croak?

Ian Piumarta piumarta at gmail.com
Thu Oct 5 22:35:18 UTC 2006


Hi,

I really didn't want to talk about any of this just yet but since there
is already a little interest (and a little confusion) I'll try to  
clarify.

 > someone can point me out to some documentation to pepsi?

piumarta.com/pepsi/pepsi.html
piumarta.com/pepsi/coke.html
piumarta.com/papers/colas-whitepaper.pdf

 > What is exactly pepsi/croak/idst?

'Id' is an object model.  It's the simplest possible model that  
permits an
object to receive a message without introducing any early bound  
assumptions
in the mechanisms.

'Idst' is a Smalltalk-like syntax (and object library) built on Id using
prototypes rather than [meta]classes.  The runtime is entirely  
dynamic but
the code compiles to a static (native) executable.

'Pepsi' is a generic name for the universe of simple object models and
languages that can be built directly on top of Id.  These exist  
mainly to
provide a message-oriented foundation for making object structures in...

'Coke' is tree-based abstraction of computation.  Structures  
representing Coke
parse trees can be converted into machine code.  One use for this  
machine
code is to populate the method tables of Id objects, or to re- 
implement its
semantics of message lookup and dispatch.

Coke has a natural textual representation as s-expressions, but one
interesting thing to do with it is build 'algebras of late-bound  
syntax' and
feed it stuff written in arbitrary combinations of arbitrary  
languages.  One
interesting syntax to describe dynamically is Idst/Pepsi.  (If you  
remember
TV ads from the 70's you now understand the working names: Coke...  
it's the
Real Thing.)

'COLAs' are combined object-lambda abstractions.  The objects form
structures describing behaviour.  The described behaviour provides the
objects with their implementation: message delivery and the  
sequencing of
subsequent messaging within methods, as a minimum.  Coke's dynamic code
generator provides incremental programming; it's static code generator
provides a 'kernel' when some subset of the system is compiled to a  
binary.
Because static code implements the dynamic execution model there is  
no early
binding trauma caused by doing so.

'Jolt' is the current prototype of Coke that can add dynamic  
behaviour to
Pepsi objects.

'Croak' is a noise made by frogs.

 > Is pepsi a system to compile small snippet of smalltalk code?

With the Idst syntax and object library, you might consider Pepsi as
something like that.  Provided you don't mind the absence of classes and
that the bootstrap compiler 'idc' generates only static code, it's even
almost usable as such.

Current work includes: implementations of some popular scripting  
languages
(JavaScript and Python); bindings to various window systems with  
accelerated
2D and 3D graphics; rewriting the dynamic code generator to support both
dynamic and static output (turning Jolt into Coke); and parsing ISO C99
platform header files to obviate FFIs and off-line 'interface  
generators' and
other similar forms of low-life.

Future plans include: a public release under the MIT license; some  
kind of
language with generic functions and first-class-selector-driven  
compilation
(maybe similar to Dylan); a version of Idst that conforms 100% to the  
ANSI
Smalltalk standard; an integrated, graphical, incremental development
environment; and a 'whole-system' implementation based on a handful of
fundamental abstractions and algorithms that is homogenous, from  
graphical
scripting all the way down to the metal.

(It's often said that Smalltalk and Lisp suffer because they are systems
that eat all of their young.  If COLA succeeds it might be called the  
system that
ate its parents.)

Hope that helped.

Cheers,
Ian




More information about the Squeak-dev mailing list