Lambda (was: Refactoring in Tunes)
Wed, 12 Jan 2000 23:58:58 +0100
Laurent Martelli wrote:
> Every one is also free to use OIL :-) (http://perso.cybercable.fr/martelli/oip/).
> But be warned that it is not (yet) fast. But it's undoubtly tiny, and
> I hope it's consistant and understandable.
> Laurent Martelli
A tipical Forth implementation is about few kilobytes in size and
usually the core is so little that you can *manually* assemble it.
A single person can understand the *complete* environment, that
traditionally it's composed by interpreter, compiler, assembler,
editor, debugger and so on, without any necessity of an OS (itself
has some features usually associated to an OS), moreover is quite
fast. However some current implementations are based on an host OS
and are big respect to the standalone versions.
Surely OIL is not so big compared to other interpreters but you
need a C++ compiler to bootstrap it and an host OS to run it (as
the vast majority of the existing interpreters and compilers).
Another excerpt from "Thoughtful Programming"
Chuck's view of programming, as I understand his description of
it, is that there is a problem, a programmer and his abstraction
and the computer. Forth was there to let the picture be as simple
as possible and let the programmer map the solution to the problem
to the computer.
Programmer with abstraction of problem
and this leading to a solution that looks like this.
Programmer's simple implementation by abstraction of the problem to the computer
This was Chuck's original idea of Forth even though in the old
days the normal picture was not as complex and layered as it has
become today. There were only a few layers between the programmer
and the computer in those days but that was the problem that Forth
was suppose to avoid. As the layers have become more numerous and
deeper it has become even more important to let Forth avoid that
Chuck wants to make the computer simple and easily comprehended so
that no extra layers of abstraction are needed to get at it or the
problem. Chuck wants to make the solution simple so that it easy
to write and efficient and has no extra layers of unneeded fat.
Chuck seeks a simple efficient abstraction of the actual problem
to the actual computer.
The people coming into computing in these times are being taught
that the picture below is reality of a computer. They face
enormous problems as a result. Almost no one gets to deal with the
simple reality of the problem or the computer but must deal with
the complexity of a thousand other people's abstractions at all
Programmers's abstractions of problem(s)
Programmers's abstractions in software (example: OO w/ late binding)
Programmers's abstractions of software reuse (general source libraries)
Programmers's abstractions of optimizing compilers knowing more than they
Programmers's abstractions of the computer GUI API
Programmers's abstractions of the computer OS Services
Programmers's abstractions of the computer BIOS
Programmers's abstractions of the computer architecture ('C')
Computer (too complex for all but a few humans to grasp)
These are two very different points of view. Chuck has said that
he would like to Dispel the User Illusion. He means that the user
has the illusion that all these layers of abstraction ARE the
computer. If they could see beyond the illusion to see only the
simple problem and were only faced with mapping it to a simple
computer things stay simple and simple methods work. The majority
of problems are avoided this way.
Chuck originally created Forth to avoid problems introduced by
unneeded abstractions. There was the abstraction of a Forth
virtual machine and the expression of a solution in terms of that
abstraction. Chuck has spent years simplifying and improving the
virtual machine and has moved that abstraction into hardware to
simplify both hardware and software design. He has a simpler
virtual machine model, implemented in hardware on his machines,
and a simple Forth environment implemented on top of it.