Archive for September 15, 2010

A robot drummer as computing student inspiration

Shimon is the next generation robot drummer, invented by Gil Weinberg, after Haile.  While I am so impressed with Gil’s work, I particularly like to use Shimon and Haile as examples for our Computational Media students.  Most often, the students who enroll in our Computational Media degree program talk about becoming computer animators or game designers, and that’s great. But that’s only part of what’s powerful about computation for expression.  Robot drummers get the students thinking about all kinds of new opportunities that they’d never thought about.  Making new kinds of devices that embed computation?  Focusing on auditory rather than visual information? What does it take to interpret human expression (by listening or watching) and responding to that expression?  What does it mean for a robot to become “social”?  This is a great example of research inspiring and creating synergies with teaching.

Shimon, an adaptive, improvisational, percussion-playing robot, is getting smarter – and more famous, with appearances in places like the Stephen Colbert show. Now, humans have been known to get a big head under such circumstances. Shimon’s head has gotten “more social” – gestural intelligence helps the robot relate to fellow players and nod its head in time to the music.

via Create Digital Music » Shimon, Percussionist Robot, Gets Smarter; A Talk with its Creator.

September 15, 2010 at 11:30 am Leave a comment

Alan Kay on Moti’s “Objects Ever?” CACM Article

Occasionally I take the blog-owner’s prerogative to re-post a comment as its own blog post.  Alan Kay, inventor of the term “object-oriented programming” responding to Moti Ben-Ari’s article on “Objects Ever?” would be reason enough.  Even better, Alan’s response offers insight into what parts of objects are most critical to use and learn.

Spoiler alert that particularly pleased me: Inheritance ain’t one of them. I have had several debates, often at SIGCSE, about the importance of inheritance. The discussion usually ends with me saying, “Read Alan’s HOPL chapter!” and my antagonist’s reply, “I don’t read history — that has nothing to do with modern languages.” What was that line again about “doomed to repeat”?

Thanks for this, Alan!

Here is the comment I added to the ACM post of the article. And I’ve added a few more things to think about below this.

I think this article raises important issues.

A good example of a large system I consider “object-oriented” is the Internet. It has billions of completely encapsulated objects (the computers themselves) and uses a pure messaging system of “requests not commands”, etc.

By contrast, I have never considered that most systems which call themselves “object-oriented” are even close to my meaning when I originally coined the term.

So part of the problem here is a kind of “colonization” of an idea — which got popular because it worked so well in the ARPA/PARC community — by many people who didn’t take the trouble to understand why it worked so well.
And, in a design-oriented field such as ours, fads are all to easy to hatch. It takes considerable will to resist fads and stay focused on the real issues.

Combine this with the desire to also include old forms (like data structures, types, and procedural programming) and you’ve got an enormous confusing mess of conflicting design paradigms.

And, the 70s ideas that worked so well are not strong enough to deal with many of the problems of today. However, the core of what I now have to call “real oop” — namely encapsulated modules all the way down with pure messaging — still hangs in there strongly because it is nothing more than an abstract view of complex systems.

The key to safety lies in the encapsulation. The key to scalability lies in how messaging is actually done (e.g. maybe it is better to only receive messages via “postings of needs”). The key to abstraction and compactness lies in a felicitous combination of design and mathematics.

The key to resolving many of these issues lies in carrying out education in computing in a vastly different way than is done today.
A few more comments here.

If you are “setting” values from the outside of an object, you are doing “simulated data structure programming” rather than object oriented programming. One of my original motivations for trying to invent OOP was to eliminate imperative assignment (at least as a global unprotected action). “Real OOP” is much more about “requests”, and the more the requests invoke goals the object knows how to accomplish, the better. “Abstract Data Types” is not OOP!

A larger problem here is that though the invention of OOP and the coining of the term were influenced by several prior systems (including Sketchpad and Simula, and others which can be found in the history I wrote for the ACM — a nice irony it turns out!), it is quite clear that the idea of OOP did not include most of its precursors.

We didn’t even do all of the idea at PARC. Many of Carl Hewitt’s Actors ideas which got sparked by the original Smalltalk were more in the spirit of OOP than the subsequent Smalltalks. Significant parts of Erlang are more like a real OOP language the the current Smalltalk, and certainly the C based languages that have been painted with “OOP paint”.

The largest problem here is that a misapplication of a paradigm is being blamed for what is really bad language and systems designs and implementations. And I agree completely with the author that most of the features cited are really bad. But they have nothing to do with OOP.

For example, Smalltalk initially did not have inheritance because I thought the way it was used in Simula was all to easily the foundation of nightmares (too many different semantics from one mechanism). Instead the original Smalltalk used many LISP ideas to allow dynamic experiments with many kinds of generalizations.

I think the remedy is to consign the current wide-spread meanings of “object-oriented” to the rubbish heap of still taught bad ideas, and to make up a new term for what I and my colleagues did.

A smaller consideration is to notice that what is good about the original idea is still quite good, but it does require more thinking (and different thinking) and design to accomplish (but with great benefits in expressiveness, scalability and safety).

Blaming a good idea for being difficult is like blaming the Golden Rule for not being easily able to be learned by most humans. I think the main points of both lie elsewhere.
Best wishes,

September 15, 2010 at 10:38 am 8 comments

Enter your email address to follow this blog and receive notifications of new posts by email.

Join 10,185 other subscribers


Recent Posts

Blog Stats

  • 2,039,878 hits
September 2010

CS Teaching Tips