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

Michael Latta lattam at mac.com
Wed Aug 5 21:13:49 UTC 2009

I agree with the distinction being raised.

No matter the language there are basic things that must be learned to  
build a working program.  It does not matter whether the thing learned  
is built-in or from a library.  Collections, control structures,  
variables, computation, etc.  A simple language that must be extended  
to implement all these basics is no easier to learn than one that has  
them all baked in.  And unless well documented from a learner's point  
of view, it could be much harder.

The value in a system like Self, and Smalltalk, and Ruby, is the value  
to the expert user.  To a programer that has mastered the language,  
the flexibility, ability to extend the language, and to implement new  
abstractions, are what make a language system stand out.  With image  
based programming there is also the ease of access to the objects and  
internals that far exceeds most memory based programming  
environments.  But, again mostly those benefit the experienced user.


On Aug 5, 2009, at 1:46 PM, Niko Schwarz wrote:

> 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
> reply that New Math failed: http://www.youtube.com/watch? 
> v=tx5KDyvlG3Q.
> 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
> ------------------------------------
> Yahoo! Groups Links

More information about the Self-interest mailing list