# [self-interest] Our two weapons are fear and surprise...and..

Wed Aug 5 19:46:38 UTC 2009

```Can I digress very briefly on this matter?

The natural numbers are actually constructed very simply and
beautifully. Or can be constructed, I should say. You start by just
sets, and define the empty set to be zero. Then you allow a set to
contain other sets. So we define 1 to be the set that contains 0. Now
we we define for each number, that the next number is the set
containing all its predecessors.

That is a beautiful definition, and the building blocks are simple: We
need only an empty set and sets that contain other sets. And we get
meaningful, elegant definitions for things like "smaller
than" (through set inclusion, in this example).

What I want to say is: Simple building blocks don't necessarily lead
to a simple system. Knowing this, in mathematical writing, I am
sometimes tempted to write n when I mean the set {1,…n-1}. Because I
know it's defined to be this way. But then I realize that that would
be queer, that the majority of the mathematicians has a very different
mental model of natural numbers. Natural numbers are these things that
define the quantities of finite sets. You ADD them, sometimes
multiply, and they fit quite nicely into the Range of real numbers,
rather isolated.

Now, you could argue that it is because that's how we get used to
natural numbers. That's how we use them every day, if it were just
taught differently, they would enjoy set tricks more. And I would

Because, you see, building systems bottom-up makes them conceptually
beautiful, powerful, sophisticated, and without rough edges. But they
also ensure that things that are fundamental to the user are really
quite involved concepts in your system. I mean, it does irritate
mathematicians if you use "element of" and mean "smaller than" on
natural numbers. Eventhough it is, in a sense, a fundamentally
equivalent thing.

The point I am getting to is, a system like Self might be beautifully
simple, because the design principles can be taught in less than a
minute. But the newbie does not NEED the design principles, he needs a
for loop. Now, given Self, he has to learn two things: the for loop
AND the design principles.

I quite understand where the OP is coming from. I've taught a few
friends smalltalk, and I was ASTONISHED to see how long it took to get
people to grasp it. Not at all less time than Java, I would estimate.
Despite the fact that Smalltalk is, conceptually, a lot easier than
Java.

Systems like Self are very easy for people like us. We know the for
loop concept, the closure concept, and the accessor concept. Self has
an elegant way to implement these, so for US Self is heaven. A good
computer scientist can probably learn Self in a day, because he knows
all the concepts already. For US, it really boils down to only
understanding the few fundamental principles of Self, and the rest
follows easily.

Maybe to wrap up, just as a case in point: in the parameterized
complexity field of mathematics, which develops algorithms in large
quantities, the usual pseudo-code for algorithmsis is imperative.

So, my point would be that there is a certain simplicity in Pascal,
that you cannot find in Self. Pascal offers a syntax piece for each
core concept that you really need to know. And not more. Not even a
break statement.

cheers,

Niko

On 05.08.2009, at 20:46, Jeremiah S. Junken wrote:

> It may have something to do with familiarity. Self and IO are both
> extremely simple, and for people familiar with either one, learning
> the other is fairly simple -- but for people who have not started
> out with something like Smalltalk, or a functional language, it's
> definitely a bit of an alien landscape with a learning curve
>
> There's conceptual simplicity and practical simplicity -- the latter
> has a lot to do with familiarity.
>
> My 2 cents in debased currency.
>
> On Wed, 2009-08-05 at 10:59 -0700, Randy Smith wrote:
>
>
>> I'm pleased you say "I agree that the language it simple -
>> semantically" as that was the intended claim. Maybe we should put
>> that in the title, but it makes it little clunky sounding.
>>
> [snip]
> [snip -- pwd vs. self ]
>>
>> I suppose the larger question might be: Every language is like a
>> carpet with a complexity bump that can be moved around from place to
>> place but never flattened out. Are some language carpets
>> intrinsically
>> less bumpy?
>>
>> --Randy
>
>
>
>

```