From: Dave Thomas <Dave@...>
Date: 2001-03-14T14:01:00+09:00
Subject: [ruby-talk:12606] Order, chaos, and change requests :)


I've been following the 'my' variable thread with a lot of interest
(and have even started a couple of sub-threads of my own).

First, I have to say that I'm proud to belong to this community. I
don't think I've ever come across a group of such smart folks who can
discuss such a broad range of ideas in such an open and positive
way. The discussions here are stimulating and rewarding.

However, I'm also aware of a trait in myself, and I suspect in others
here, to look for tidiness in things that aren't necessarily tidy. And 
I'm beginning to be concerned that some of the ideas we're pursuing
could actually damage the thing we're trying to improve.

Let me try to explain.

I start by thinking that Ruby is something special.  Every one who
uses it finds a certain resonance with their way of thinking but no
one can say exactly why. It just feels right. Why is this?

I've recently been reading a lot about complexity, chaos theory and
complex adaptive systems. A lot of this work applies to the everyday
work of organizations and people. It starts by looking at stability.

On one side, there are totally stable systems, ones where you can
disrupt things all day and nothing changes. It's hard to get anything
done in these: you work and work and nothing moves.

On the other side, there are totally chaotic systems.  You can pound
away at these too, but as they are chaotic, there's no correlation
between what you do and what they do.  Again, nothing effective really
gets done.

In between are what are termed chaordic systems: balancing between
CHAos and ORDer. A chaordic system swings between being stable and
unstable: every now and then the system undergoes seemingly impossible
changes in direction. A true chaordic system behaves as if it had
almost no inertia.  These systems are fragile--in fact they _have_ to
be fragile in order to work, but within them you can achieve great
things, because small inputs can have large effects. In a chaordic
system you don't dictate what gets done: instead you provide a fertile
environment in which new ways of doing things can _emerge_. Chaordic
systems are exceptionally effective at getting things done.

Somehow, Ruby sits in this space.  It certainly isn't tidy and stable:
it's full of non-orthogonalities, and there are few hard-and-fast
rules.  But at the same time it isn't chaotic. Interestingly, if you
ask Ruby enthusiasts why they love the language, you often get answers
which talk about Ruby bridging two worlds, or merging multiple
ideas. Things just _emerge_ when you use Ruby.

Now, my concern (remember my concern).  We're dealing with something
great, but at the same time fragile. Making major changes is risky, as
we could end up destroying this mysterious quality.  So I believe that
we should do as Matz does and be conservative when making changes,
asking ourselves how this change fits in with the whole.  That's why I
liked Steven White's post [ruby-talk:12594]: it went beyond a
localized problem and looked at the broader picture.  However, by
doing that, it also changed the dynamic that is Ruby.  Suggesting it
as the way to move forward could end up doing damage, simply because
we don't really understand the underlying qualities that make it work
now. (And I'm not singling out his post: it really did strike me as
excellent. I was just concerned that what we'd end up with might not
be Ruby).

So, am I suggesting that we do nothing to Ruby?

No.

Instead I'm beginning to think that maybe this is a job for Robert
Feldt's Ruby-in-Ruby or Matju's MetaRuby (or something similar). I
think we should create a simple testbed for all these new language
ideas, a Ruby implementation that's easier to hack than the current
interpreter, ideally written in Ruby itself.  Then we can implement
and try out all these ideas without having to _guess_ about their
impact on the language, and without having to rely on Matz to
implement them. Want to see the impact of making do/end blocks have
local scope? Spend a couple of days hacking your version of the
testbed, and try it.

Eventually, someone will come across an idea that really shines, that
broadens the smile.  And then we say 'let's add this back in to the
mainline'.

Going back to the chaos theme: one of the keys is to encourage
emergence, and to make it acceptable and (relatively) painless to make
mistakes.

So, let's carry on discussing all these great ideas. But let's also
think of ways of going beyond discussion into experimentation, and
ways of doing that without risking the harmonious beauty that is
Ruby.

It's also OK to be messy sometimes :)


Regards


Dave