A call to semplicity (was: Lambda (was: Refactoring in Tunes))
Thu, 13 Jan 2000 16:06:18 +0100
James Little wrote:
> > Laurent Martelli wrote:
> > >
> > > Every one is also free to use OIL :-) (http://perso.cybercable
> Massimo Dentico wrote:
> >Another excerpt from "Thoughtful Programming"
> >- http://www.ultratechnology.com/forth.htm
> > 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 problem I have with this approach is that real-world problems lie
> in entirely different domains than that of the computer. For
> example, I'm currently wrapping up a project whose problem statement
> could have looked like this:
> "We need a way to store and access information about companies and
> contacts. We need to be able to create "projects" involving these
> companies and keep a communication log and to-do lists involving
> these projects. Furthermore, we need the information to be
> centralized and accessible over the Internet. And we want to be
> able to access the data from other people's computers, so it the
> method of access can't require any special setup other than an Internet
> connection. Oh, and the solution needs to be easy to use and
> understand, and reasonably speedy on a Pentium 100.
> This is a classic "line of business" problem, the kind upon
> which the vast majority of America's programmers work. (Presumably
> the same is true for the rest of the world, too.) Computers, on
> the other hand, do arithmetic, flow control, and bitwise I/O.
> I don't see any simple abstraction of those concepts to the concepts
> involved in the problem statement above.
> > 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.
> I don't deny that the computer is simple. It does arithmetic, flow
> control, and bitwise I/O. But the problems are NOT simple. And
> that's why abstractions are so crucial. If I had to think about
> the simple computer's simple manipulation of bytes every time for
> every single kind of database query I send over the Internet, the
> proliferation of simple things would grow so huge it would overwhelm me.
> No, give me abstractions, lots of them, so I can choose the ones
> that most closely relate to the problem I'm solving. When I want
> to do arithmetic, then I'll consider giving them up. But my
> customers don't want to do arithmetic. (They've got calculators for
> that.) They want to do things that don't relate to the computer at all.
Please Jim, you make banal the reasoning and end up with banal
statements! He has never asserted (nor I) that abstractions are
useless, read well:
Chuck *seeks* a simple efficient abstraction of the actual problem
to the actual computer.
[... and ...]
Chuck originally created Forth to avoid problems introduced by
Mr. Moore uses this minimalistic approach and Forth to solve so
called *real-world problem* with success since about the second
half of the sixty. He considers himself an application programmer
*not* a researcher into the field of programming languages or
operating systems. He has refined his method and tool under
constant pressure to developing reald world applications.
For an history of Forth and examples of successful applications
see: - http://www.forth.com/Content/History/History1.htm
I have posted here these references exactly bacause I'm a strong
proponent of solid theoretical basis for Tunes, but at the same
time this theory could not be an end in itself. As understand it,
the Tunes project wants to address *pratical* problems with the
best possible theoretical approach. We need to object to the
theory by means of objective facts.
Sometimes a wrong abstraction could create more problems than it
could solve them. An example from the theory of complexity(?) is
the big-O(?) notation (I don't know if these terms are correct in
english). Coarse semplification of this technique idealize the
machine and the algorithm in a manner that the results can be only
poorly correlated to the reality or, worse, not correlated at all.
So, I propose an empirical approach.
As Brian Rice has written recently:
> It's great that you're working on your ideas, but please be open
> to ideas that others have had so you can build from their
> mistakes and successes. Otherwise, you will (I guarantee)
> stumble into problems, that others have addressed and studied,
> without any sort of vision.
What we can learn from Moore is that his call to simplicity has
proven been successful. So, the big questions are: what is a
*good* abstracion? What is an *unjustified* (to introduce into a
However Jim, yours is a fairly common reaction even in the Forth
community. Jeff Fox address it in a passage from the cited article:
People try to distort and trivialize Chuck's by saying that he has
removed everything that is needed from Forth and they don't
understand why. But Chuck didn't just remove things to remove
things. He removed things when he found a simpler way to solve the
same problem that something was there solve. Often to solve a
problem you have to add x-y-z. But then x-y-z introduces some more
complexity and as a result you have to then also add a-b-c and
d-e-f. Now everyone gets used to x-y-z and never considers any
other way to solve the problem that x-y-z has solved for everyone
for so many years. They also never consider that a-b-c and d-e-f
may also be viewed as problems that are begging to be fixed by
being removed. Otherwise as time goes by they become bigger and
bigger problems and as code is developed and added to the system
they will lead to more complexity.
So Chuck will rethink the problem. He will find a different way to
do x-y-z, or better yet to avoid the problem that x-y-z solved.
Now the x-y-z solution that everyone has been using for some
problem is no longer needed because something better is now
available. It gets done because now he can also remove a-b-c and
d-e-f since they were just needed to support x-y-z. Things become
simpler, clearer, easier to use, easier to maintain, because
unneeded fat has been removed and there are fewer complications.
But people who have been doing x-y-z for twenty years are
horrified at the prospect of not using it. They cannot imagine
Forth without it. None of their code would run without it. They
would have to rewrite code to not use x-y-z and writing code is
hard for them. They also cannot imagine living without a-b-c and
d-e-f because they once again their old code is full of that and
they never considered doing it any other way.
Chuck doesn't just throw stuff out because he is compelled to
minimize. He is compelled to experiment and improve his code. He
is not against throwing something out if he finds a way to be more
productive without it. He throws stuff because he can more
productive by doing things in a better way, cleaner, clearer,
simpler. He does not think that he came up with the perfect
language 30 years ago any more than he feels he has the perfect
language now. He will always want to change and improve what he is
doing and he will always be looking for new ideas to make it
better. He has been on a clear path to make his language, Forth,
smaller, simpler, easier, more powerful, faster, less buggy, more
maneuverable, etc. But each time he finds a way to improve
something,through extensive experimentation and pragmatic analysis
many people have knee jerk reaction and say, "He took out what? I
can't live without that! What is he thinking?". But rather than
ask what he is thinking and ask him to explain why it is better to
do Forth without x-y-z many people just say, "x-y-z is standard
practice by the average programmer and is part of the ANS
standard. I don't want to even consider the idea of removing x-y-z
and I have interest in listening to the arguments. I will just
post stuff for other people about how I know that Chuck knows that
x-y-z is really good and that he is just trying to mislead people.