Talk Like A Duck

A Personal RubyConf 2008 Recap

Posted by Rick DeNatale Tue, 11 Nov 2008 01:11:00 GMT

RubyConf 2008 has come and gone. It was a great opportunity to meet Ruby friends and make new ones.

I think that my talk on Friday afternoon went well. It’s amazing how your perception of the conference changes when you shift from fretting about your upcoming talk, to relief once it’s done. I don’t know how many times I’ve given talks to similar audiences, but the butterflies never seem to stay away, and I think that it’s a good thing since it keeps you on your toes. If you are going to be in western Michigan on the evening of November 25th, I’ll be reprising this talk at XP West Michigan.

A Quick Sample of RubyConf 2008 Speakers

Greg Pollack has put up a preview of his upcoming “RubyConf Trailer” RubyConf in 90 Seconds. As he did earlier for this year’s RailsConf Gregg did brief video interviews of as many conference speakers as he could. He’s planning to edit these together, and provide them as kind of a video “Table of contents” to the full talk videos which will be appearing on the Confreaks web-site. Coby Randquist of Confreaks told me that he expected all the videos to be available by a week from today.

A Walk Down Memory Lane

Josh Susser, who is another Rubyist with a background in Smalltalk, tweeted during my talk, that I was “taking a walk down memory lane.” In a way, RubyConf 2008 was very much a walk down memory lane for me. Not only did I reminisce in my talk, but I got to see some old familiar faces from the early days of OOPSLA in the 1980s and 1990s. Allen Otis, who served as the technical half of the team from GemStone presenting MagLev was one. Another was Monty Williams, also of GemStone. I had a very nice lunch with Monty and his wife on Saturday, along with another more guy who had recently joined GemStone to work on MagLev, who we probably bored with old war stories.

Things I learned at RubyConf 2008

In no particular order:

• Werewolf fever seems to have died off. As far as I could tell, no werewolf games materialized. The two main instigators weren’t there. Marcel Molina, apparently never was coming, and Chad Fowler, unfortunately, had to stay away due to the sudden death of his father-in-law. On the other hand, the musicians, some of them former werewolves, were there in force, leading to an enjoyable jam session.

• Jim Weirich and I established that I’ve got a year or two on him, although my hair has retained a bit more of its color.

• I also found that I wasn’t the oldest attendee, but I won’t reveal his or her identity.

• “PragDave” Thomas gave a great talk, challenging the community to “fork Ruby”, that is to spawn some incubator branches of the language to experiment with new ideas without delaying or derailing the main Ruby language. If some of these forks produced value, they might have their ideas merged back. Some of his ideas for forks were Ruby-lite, which had lots of cruft which is not often used removed. Another was Otuby (for optionally typed Ruby), which was different from Charlie Nutter’s Duby

  I thought that the most interesting was probably Cluby, or Ruby with Closures. By making some lexical changes to the language, Dave suggested that Cluby could allow blocks to always be lambda literals, and to allow blocks to be used in many more places, such as for ANY argument to a method. This would allow control flow to be implemented by methods, for example an if method which took an argument to be tested, and one or two blocks, to be executed depending on the truthiness of the first argument, or a looping method which evaluated it’s second block argument as long at the first block argument evaluated to a truthy value. He also did away with grammar for both method definitions and class/instance variables. Methods would simply be blocks which would be called when the object received the corresponding method selector in a message.

  He acknowledged, that “Smalltalk had already done this.” Which is half-true. Smalltalk alows arbitrary block closures as arguments, but you need to look at a language like self for the unification of methods and attributes.

• There are some talented musicians in the Ruby community. This wasn’t surprising since there seems to be a positive correlation between talent for programming and talent for music. Jim Weirich is an avid, and accomplished guitarist, and David Chelimsky and Diego Scataglini blew me away with a cool acoustic jazz guitar duet! I gotta give those guys, some RSpec!

• Appropriately enough, since we were so close to Epcot, once again I learned that “it’s a small world after all.” My wife was along with me, although she didn’t hang out at the conference. On Saturday evening, Deborah and I tagged along with a group which included Matz and the members of his team who were there as well as a few of us gai-jin. Deborah is half-Japanese, an Air Force brat who spent a couple of tours of duty in Tokyo during her formative years. She sat next to Matz and they talked a lot in both Japanese and English. At one point Deborah was telling Matz about some of our Japanese IBM/ex-IBM friends. When she mentioned Kuse-san, who had visited with us several times when he was here on business, Matz said “I know Kuse-san!” In retrospect this isn’t surprising, since Kuse-san, now the director of IBM’s Tokyo Research Lab, has a background in object oriented languages.

And to put a cap on a week full of personal memories, Deb and I flew back home on Sunday for an evening from the 1960s with Ed Sullivan, old VW ads, and the “Beatles.”

Posted in ruby, war_stories | Tags rubyconf | 4 comments | no trackbacks

Will It Go Round in Circles?

Posted by Rick DeNatale Wed, 15 Oct 2008 19:24:00 GMT

I really like seeing the resurgence of interest in my second most favorite programming language

One of the comments to the referenced Gartner Group blog post had a link to an IBM Developer Works article about using using Eclipse as a Smalltalk IDE.

It seems like a strange loop, since Eclipse is the descendant of IBMs old VisualAge. Now I happen to know a bit about this since I was involved at the beginning. I guess that enough time has passed that nothing I say here will affect anyone’s business.

IBM, Smalltalk, and VisualAge

VisualAge started out as a demonstration prototype I wrote using Digitalk Smalltalk/V. The idea was to make something like the NeXT interface builder in Smalltalk as an adjunct to the Smalltalk IDE. For those who are not hip to such things, the Interface Builder, originally a Lisp program before Steve Jobs hired the author, lives on as part of Apple’s XCode tool suite for OS/X for the Mac and the iPhone.

The demo got some key IBM executives excited, and so the VisualAge development organization was born. Development proceeded using Smalltalk/V, along with Object Technology International’s (OTI) Envy/Developer, which was the state of the art version and configuration management for Smalltalk team programming.

As the project progressed, IBM and Digitalk had a falling out over conflicting views of who should be doing what. I’d shown the prototype to them in my position as liaison between the two companies, and they launched their Look and Feel kit which was seen by IBM management as competition from a supplier. So since we already had a relationship with OTI because of Envy/Developer, and OTI was in the business of building Smalltalk VMs, including the VM used by Digitalk’s Smalltalk/V for the Macintosh, IBM switched horses and contracted OTI to build “IBM” Smalltalk. This eventually led to the acquisition of OTI by IBM Canada.

This was about the time we founded the ANSI X3J20 committee to forge a standard across the existing and emerging Smalltalk implementations. I served as the secretary of X3J20. Some of the other members included Peter Deutsch and Glenn Krasner of ParcPlace, which Xerox had spun-off from their Palo Alto Research Center to commercialize Smalltalk-80; George Bosworth of Digitalk; Allen Wirfs-Brock of Instantiations one of the more successful Smalltalk consulting companies in the Portland Oregon suburbs; David Simmons who was the brains behind the iconoclastic Smalltalk/Agents; and Bruce Schuchardt who worked for Servio-Logic or Gemstone, I can’t recall which name they were going under at the time. I’m sure that I’m forgetting some of the players, but I’ll plead senility.

One of the great joys of working in Smalltalk during it’s first “glory days” was the opportunity to work with and exchange ideas with such brilliant people in IBM, OTI, and other companies.

VisualAge grew to become an entire family of development environments for several of the IBM “SAA” programming languages. There was even a VisualAge for Cobol! All of the various flavors featured an IDE written in IBM Smalltalk.

Enter Java

When Java “reared it’s head.” IBM, of course came out with VisualAge for Java. Again, the IDE was written in Smalltalk, although, in order to accomodate Java execution, OTI developed what was called the UVM (or Universal Virtual Machine) whcih could execute both Smalltalk and Java byte-codes, and used Smalltalk to implement the Java primitive functions which were implemented in C in the Sun JVM.

IBM eventually switched its focus from Smalltalk to Java. After considerable thought about this, and conversations with those who were in a position to know, I’m now convinced that this had nothing to do with the relative technical merits, and everything to do with a combined IBM/Sun platform play against Microsoft.

VisualAge for Java did eventually move away from the UVM for Java execution, primarily because the Java language had evolved to provide a standard C api for extensions. OTI began implementation of a new JVM, which was dubbed J9, which was built from the ground up to be usable in embedded systems.

OTI had a reputation of fostering the use of Smalltalk in embedded systems. When I first became aware of them in the early OOPSLA days, they were showing off products like an HP Network Analyser, and a TekTronix Digital Oscilloscope which used Smalltalk to implement their user interfaces. They were also involved with a large semiconductor company in Texas which was planning to use Smalltalk in controllers in an automated IC fabrication facility.

Around the time of the birth of J9, IBM was becoming quite interested in embedded software, under an initiative called Pervasive Computing (PVC). Because of this, OTI now an IBM Subsidiary, started working on VisualAge Micro Edition, which bundled J9 with an cross-platform IDE written, this time, in Java. About this time, I moved from IBM to OTI, and ended up working on the VAME IDE.

The Emergence of Eclipse

Work on VAME was distributed between various OTI labs. The lab in Phoenix acted as the liaison with the IBM PVC folks, the J9 VM work was done in Ottawa, Raleigh did some applications work, and some UI work, but the bulk of the VAME UI framework was done by Erich Gamma’s team at OTI Zurich. The IDE used Swing, as most Java desktop apps did in those days, and apparently that was a bit of a struggle. OTI used to have an annual all-hands internal developer conference in sunny early February Quebec, and I’ll never forget Erich, who is quite the Alpine skier, talking about the UI while showing a slide he took at some ski report showing a sign with a precariously oscillating chair-lift and a skier about to fall, with the text “Don’t Swing!”

This led to the desire to develop a new UI framework and what is now known as the standard widget set or SWT.

And the overall IDE/UI framework which replaced VAME was, of course Eclipse.

And now it seems we’ve gone from a Smalltalk IDE hosting Java development to the reverse!

Where Are They Now

Digitalk eventually merged with ParcPlace to form ParcPlace-Digitalk. For a while, both Smalltalk/V and VisualWorks/Objectworks (the ParcPlace Smalltalk-80 products) were carried, but eventually VisualWorks survived. It’s now shepherded by Cincom, which bought the rights.

Similarly, IBM eventually sold the rights to market and develop VisualAge Smalltalk (a.k.a. VAST) to Instantiations. My old friend and colleague from IBM John O’Keefe “retired” from IBM to lead the development team.

Several of the X3J20 guys went to or through Microsoft. George Bosworth worked for several years on a precursor to today’s Microsoft DLR. Davd Simmons and Allen Wirfs-Brock both work on Javascript for Microsoft.

And, of interest to the Ruby community, Gemstone is now working on Maglev, a Ruby implementation with persistent objects based on their mature Smalltalk product.

Posted in war_stories, smalltalk | Tags digitalk, gemstone, j9, maglev, oti, parcplace, visualage, x3j20 | no comments | 1 trackback

Essence, Ceremony, and Deja-Vu

Posted by Rick DeNatale Thu, 21 Aug 2008 18:13:00 GMT

Stu Halloway just pointed out an interesting article on a Scala blog.

Stu asks us to consider whether making a Scala object an application by extending a trait, as described by the Scala article, affects the question of essence vs. ceremony. It certainly does cut down on boilerplate code.

Although this appears to be part of the standard Scala library, it is documented in such a way as to discourage its use, for the same reasons given in the article.

What strikes me is that the reasons seem to be tied up in language implementation and in particular the ways of the JVM. Perhaps this is an example of how the JVM, at least as it is today might be a good, but not the best platform for dynamic language implementation.

Putting on my old curmudgeon’s hat, this strongly reminds me of the early days of PL/I. The earliest PL/I compilers were notoriously bad at generating efficient code for subroutine linkage. PL/I was designed for the IBM/360, which used a subroutine calling mechanism entailing chaining invocation frames in a doubly linked list rather than on a stack. The brute force way to do a call was to perform a system getmain (OS/360 for malloc) at the beginning of a subroutine, and a freemain(free) upon return. This was fairly expensive.

As a result of this, early PL/I programmers were admonished not to use subroutines/functions, or at least to use them sparingly.

This is not bad language design, it is bad implementation.

And perhaps it is just one example, or maybe there are two here, one in Scala and one in PL/I, of how well meaning decisions based on the characteristics of the implementation at hand, particularly when compounded can give us magnificent complexities, that we really don’t need.

Posted in war_stories | Tags essenceandceremony, scala | no comments | no trackbacks

How Did You Get Started in Programming

Posted by Rick DeNatale Sun, 08 Jun 2008 03:14:00 GMT

Joe O’Brien wrote an article about How he got started in programming.According to Joe, this is a meme started by Michael Eaton, and Sarah Dutkiewicz. It seemed like fun, so here’s my story, in the same form used by Michael and Sarah.

How old were you when you started programming?

I would have been 18 or 19. It was my freshman year in college (1970/71), but I can’t recall whether it was first or second semester, and my birthday is in December.

How did you get started in programming?

Let me go back just a little bit. When I was in high school, I was very interested in music. I’d played in various rock and blues bands since junior high. My high school in Connecticut was part of a program which taught electronic music. This was a time when synthesizers were just coming to the fore. Walter (now Wendy) Carlos’ album “Switched on Bach” had come out in 1968 when I was a high-school sophomore.

So I started at the University of Connecticut in the fall of 1970 and enrolled in the Electrical Engineering School, with the sole intention of becoming the next Robert Moog. All I really wanted to learn was how to design voltage-controlled oscilators and amplifiers.

One of the courses which all freshman engineers at UConn had to take was a 100 level CE course which consisted of one-half semester of “Engineering Graphics” i.e drafting on a board with a T-Square, Triangles and French-curves, and one-half semester of Fortran I programming on an IBM 1620.

That course got me hooked on programming, and my musical career ended in a hurry.

What was your first language?

As I mentioned it was Fortran I, but I quickly became one of those guys who wanted to dabble with every programming language I could get my hands on.

What was the first real program you wrote?

It’s been so long that I can’t really remember. One of the things I remember from school was writing a compiler as a class project. I also remember a computer architecture (hardware) course, taught by grad student with a recent math MS, who I baffled by designing a computer for the term project which had a very simple hardware design, because it was micro-programmed so the main part of the design was actually firmware. The poor guy didn’t really know what to make of it.

What languages have you used since you started programming?

This is probably not a complete list but:

• PL/I
• Snobol
• Lisp 1.5
• Formac
• 1620 Assembler Language
• PDP 8/5 Assembler Language
• IBM System/360/370 Assembler Language
• APL
• PL/S – an IBM internal mid-level language akin to C but with a PL/I like syntax, and a later variant PL/AS
• Basic – on the APPLE ][
• UCSD Pascal
• C
• Class-C, an object oriented C variant similar to Objective-C which I invented for use within IBM
• Object Pascal (using MacApp)
• C++ (as little as possible)
• Smalltalk – my first real love
• Java – mostly because I had no choice
• Ruby – my current love
• JavaScript – which I’ve decided is my language of the year for 2008.

If you knew then what you know now, would you have started programming?

Only because I can’t figure out how to become a real Rock Star.

If there is one thing you learned along the way that you would tell new developers, what would it be?

Try to get a broad a picture as possible of programming, try to use your knowledge of other languages enhance your learning of new ones instead of inhibiting yourself by misunderstanding how the languages differ from the ones you’ve already used,

What’s the most fun you’ve ever had … programming?

The most enjoyable aspects of programming are the social ones. I was doing pair programming before anyone had coined the term. I remember sessions where two or three guys were working on something, one working the keyboard, one the mouse, and maybe a third kibitzing. Beyond that it’s great to hang out with other programmers whether at local groups or at a conference like OOPSLA or RubyConf and talk about the craft of programming, maybe over a beer or two.

Posted in war_stories | no comments | no trackbacks

What Would You Miss If You Had To Stop Using Ruby and Go Back to Smalltalk?

Posted by Rick DeNatale Wed, 21 May 2008 20:58:00 GMT

Last night, James Robertson from Cincom, presented Smalltalk and Seaside to the Raleigh Ruby Brigade.

It was an interesting deja-vu experience, since in my younger days, part of my job with IBM was evangelizing Smalltalk, much as James does today. It was interesting to see what has and hasn’t changed. For the most part the things about Smalltalk which were blessings and curses (or many times both) haven’t changed. The IDE is still powerful. It gets much of it’s power from Smalltalk’s model of how source code and run-time implementation objects like compiled-methods, classes and metaclasses interact, but the consequence is that there aren’t really Smalltalk source files to use with popular editors like VIM or EMACS or Textmate. The question came up about whether the Smalltalk IDE supported the notion of giving the code to an external editor, and the answer was that the size of a typical Smalltalk method, which is the unit of editing, was so small (10 lines is a long Smalltalk method) as to make it ‘moot.’ I used to get the same kind of questions and give pretty much the same answers.

One area where Smalltalk really does excel is in it’s debugging and inspection tools. The same implementation object model which enables browser features, like finding all senders or implementers of a message using structural rather than textual searching, also allows live debugging, where you can not only inspect the run-time state at a breakpoint, or when an exception occurs, but actually make changes to the running code, and compile those changes, at which point the VM prunes the invocation stack down to the point of the change and allows you to restart from that point. Protestations from TDD/BDD adherents that you don’t need no steenking debugger if you follow TDD practice, the Smalltalk debugger was tool much favored by the very people, like Kent Beck, who invented TDD. Many Rubyists who were around for more than a year or two had an anti-debugger attitude, generated more, I suspect, by the lack of a decent Ruby debugger than any real hatred of debuggers.

Now that ruby-debug has been around for almost two years, the situation is much better. Ruby has a fairly competent debugger which allows stepping through code. It’s still hampered by Ruby’s rather simple run-time meta information, being forced to work on a line-by-line mode, rather than being able to step through individual expressions as can the Smalltalk debugger. And we’re still a long way from the live surgery capabilities I described. Perhaps as Ruby VM implementations mature we might see some of these advanced features emerge, perhaps this is something which the Rubinius implementers might also take as an inspiration from Smalltalk. This is one of the main things I miss from my Smalltalk days.

On the other hand, at this point in time, I’m really much happier working in Ruby than I think I would be were I somehow forced to work in Smalltalk again instead. Much as I love it, Smalltalk is now my second favorite language.

At one point last night, Brian Adkins asked me the question which is the title of this article. I think it’s a fair question, and I’m not sure I know exactly, but let me try to answer it.

What I’d miss from Ruby

I’ve said this before, but one of the things I like about Ruby is that it is more dynamic than Smalltalk in ways which I like, and cuts back on other aspects of Smalltalk which I don’t think are really that important.

One of the things I like about Ruby is the elimination of variable declarations. A good example of this was that during the Seaside demo last night, James showed how interfacing to the database requires attribute instance variables in model objects to be declared. Now the IDE provides tools for helping with this, you get prompted with a list of column names and can add them one by one just by clicking buttons. Contrast this with ActiveRecord where model objects just acquire instance variables dynamically at run-time. Now I know that some prefer more explicit mappings, but personally I feel that the dynamic mapping provides much more capability for much less ceremony.

The ways in which Ruby is more dynamic than Smalltalk seem to me to provide better facilities for building low-ceremony architectures and artifacts like Rails, Rake, etc. There are more dynamic languages than Ruby to be sure, such as Self, and from what I can sense JavaScript, but Ruby seems to strike a very nice balance.

Much has been made of the legacy of Smalltalk in pioneering metaprogramming, although some Lisp guys might quibble with that, and in truth, most Smalltalk metaprogramming was only used to support the IDE and never put to use by application programmers. Alan Kay used to say that he was disappointed that no one seemed to make new classes of Behavior (which is the superclass of both Class and Metaclass in Smalltalk). I know he said this to some of us at an IBM internal conference, which at least led to Dave Smith and Jerry Archbald developing a “behavior of behavior” tutorial which ran for several years at OOPSLA. But Rubyists have taken metaprogramming much further than I recall from my Smalltalk days.

On the other end of the scale, Smalltalk as James pointed out, as I used to, has a very simple syntax, a few reserved words (self, super, nil, true, and false), three types of messages (unary, binary, and keyword), two operators (:= for assignment, and ^ for return), and a few more things for defining block literals.

Now when I was doing James’ job, this got mixed reactions. Some people took to syntax like:

topLeft = Point x: 3+2*5 y: 15

While others found it just a little too strange, something which we Smalltalkers just couldn’t get.

Another thing which put off newcomers to Smalltalk was that, because of the simplicity of the language, and the lack of any form of operator precedence (remember the only operators are := and ^), that subexpression 3+2*5 evaluates to 25 and not 13.

Ruby trades off a little simplicity and does provide precedence between messages which seem like they should act as operators.

I’m not saying that Ruby is without quirks, just that different people react to different quirks in different ways. If you don’t like what you perceive to be the quirks of any programming language, you won’t be convinced, even by the most ardent supporter of those quirks.

One of the interesting effects of the Smalltalk syntax was that, as we observed back in Smalltalk’s heyday in the Enterprise (late ‘80s-early ‘90s), it seemed that a lot of COBOL programmers seemed to take to Smalltalk. We used to think that Smalltalk might actually become the 21st century COBOL, until the “Enterprise” got wooed away by EJBs and the like. The same things which made Smalltalk approachable by COBOL programmers made it seem weird to those who looked down on those COBOL programmers as “trade-school” programmers.

Another much-touted feature of Smalltalk, is that everything is done by message sending, even control flow. In Smalltalk a if/then/else control flow is achieved by sending an ifTrue:ifFalse: message to a boolean object as in:

 ^(x = 0) ifTrue:[a] ifFalse:[b]

Smalltalk evaluates this as if the the expression (x = 0) is evaluated by sending the message with the selector = and argument 0, to the object referenced by x. The result of that message, an object of course, is then sent the message with the selector ifTrue:ifFalse: and the arguments [a] and [b], which are two blocks. What happens is up to that object. Typically that object is either true (the sole instance of the class True) whose ifTrue:ifFalse: method evaluates the first argument, or false (the sole instance of the class False) whose ifTrue:ifFalse: method evaluates the second argument. Very neat and conceptually clean. It allows you to define your own control flow methods.

Ruby on the other hand compiles if statements and their kind as tests and branches, much as a C compiler would. We trade off a little flexibility for performance.

But, in my experience, that flexibility rarely got used in Smalltalk. Not only that but, in my day at least, the Smalltalk compilers would also compile ifTrue:ifFalse: to a test of the result of the ‘receiver’ and a branch. In fact I just tried defining a FakeBoolean class with an ifTrue: method and when I try to use it I see this:

That NonBooleanReceiver exception is like seeing the Wizard of Oz behind the curtain, this notion of no control flow, just messages is actually a bit of an illusion.

Again, while Ruby doesn’t even pretend to implement all control flow by messaging, it provides most of what the underlying Smalltalk mechanisms are really used for in the form of blocks used to implement iterators.

There are other aspects of Smalltalk which are both blessings and curses. The fact that Smalltalk has a persistent run-time image, containing all the development tools, which can be saved along with its state of execution, and restarted is quite powerful, alien to many programmers, and can drastically change your approach to deployment. Back when I was doing Smalltalk we always struggled with issues like the footprint of the image, how to strip out the development tools before deployment, and start-up time. Some of these problems might seem to be less severe with today’s hardware, but they are still issues.

I feel that I might be coming across a little too harshly on my old friend Smalltalk. It still provides a great programming environment, and serves as a source of inspiration which shouldn’t be overlooked, and I hope to see some of the powerful development tool features from Smalltalk appear with help from support in some of the emerging Ruby implementations. I’m glad to see that it seems to be making somewhat of a resurgence, along with dynamic languages in general. But for me right now, while I wouldn’t be unhappy if I had to go back to Smalltalk, but I feel happier with Ruby.

Posted in ruby, war_stories, smalltalk | Tags debugging, seaside | 5 comments | no trackbacks

Cool, but Stupid, Things I've Done

Posted by Rick DeNatale Sat, 17 Nov 2007 11:18:00 GMT

Cones
© Eric Castro

Many of these things can be cool.

And many of them, particularly in retrospect, can be less than brilliant.

Here are two of the more visible cool, but stupid things I've done in the past.

Posted in war_stories, smalltalk | Tags smalltalkdistributed, stupidity, visualage | 1 comment | no trackbacks

To paraphrase Kent Beck...

Posted by Rick DeNatale Sun, 02 Sep 2007 21:35:00 GMT

I’m catching up on my RSS feeds this afternoon, and I just ran across the latest from John Lam. Which exposed an interesting coincidence.

Oh yes, Merlin is the original code-name for our team, which was originally IronPython but has now expanded to include the Dynamic Language Runtime and IronRuby.
- John Lam

The codename for IBM’s original VisualAge project was “Camelot.” Various subcomponents and follow-ons were dubbed with various names from Arthurian legend. For example, there were components with names like “Lancelot” and “Guinivere.”

Sometime after the initial success of VisualAge, it was decided that IBM would actually produce a separate Smalltalk language and IDE packaging, a product which was originally named “IBM Smalltalk” at launch.

But during development IBM Smalltalk had Arthur’s wizard as its namesake. As usual there were tee shirts, and this article starts with a picture I just took of my copy of the IBM Merlin Tee, which my wife still uses as an exercise tee. And in case you can’t read them, the words in the crystal ball read “think BIG/TALK small” a combined reference to IBM, Smalltalk, and I suppose, Teddy Roosevelt. Now old Merlin might look more like a Swami than the wizard of Camelot, but here’s the proof from the front of the shirt:

So to paraphrase my old buddy Kent Beck, I knew that Microsoft was trying to implement Ruby, but I didn’t know it would be called Merlin!

Posted in ruby, war_stories, smalltalk | Tags ibmsmalltalk, ironruby | no comments | no trackbacks

Nobody Could Count Beans Like IBM

Posted by Rick DeNatale Sun, 02 Sep 2007 20:52:00 GMT

In my thirty-two year career at IBM, I can’t begin to count how many times I was bothered by the IBM software development process.

When I started, in 1974, I found myself trying to swim under the waterfall. Everything hinged on “Requirements Documents,” “Initial Functional Specs,” “Design Reviews,” etc. Managers were constantly wanting line of code estimates. Far more effort was wasted on process rather than progress. Sometimes the process overhead was fatal. My first project at IBM was part of IBMs major initiative in the 1970s to replace the IBM/370 with a new system called “FS”. One of my heroes at the time was John Sowa who worked in the architecture department and whose role seemed to be the resident iconoclast. In one of his memorable memos available on his web site, John made the observation that the system architecture specification comprised fifteen registered IBM confidential documents, each with an individual need to know. A fact which effectively prevented anyone in the company from understanding the system and its problems.

So, it should be no surprise that I came to an appreciation of what are now called agile methods, early on in my career, and fought for the processes and technologies which enable agility inside IBM, and evangelized such approaches to IBM customers.

Fred George was one of my allies during part of this struggle. Fred was a middle-level IBM manager who came to the IBM lab in Cary, NC about the time we started using Smalltalk, and I was developing a prototype application development tool which morphed into VisualAge. I worked in Fred’s organization and claim influencing him on dynamic OO technology, and agile methods.

Fred now works for ThoughtWorks, and blogs about agile methods. Recently he has been writing about how to push back against bean-counting. I get the sense that Fred shared many of my frustrations with the old IBM process.

Posted in war_stories | Tags agility, IBM | no comments | no trackbacks

After the Hoedown is Over, Part 1

Posted by Rick DeNatale Tue, 14 Aug 2007 15:03:00 GMT

The first Ruby Hoedown, sponsored by the Raleigh Ruby brigade, has finally come and gone. I had a great two days, saw some old friends, and made lots of new ones.

Here are my initial thoughts after more than a bit too litle sleep after a night trying to root out werewolves.

Posted in ruby, war_stories, smalltalk, rails | Tags history, rubyhoedown | no comments | no trackbacks

The other Dave Thomas and the Birth of the Agile Alliance

Posted by Rick DeNatale Mon, 09 Jul 2007 17:17:00 GMT

“Uncle Bob” Martin of Object Mentor just published an article containing his personal recollection of how the

... Dave Thomas of OTI fame. (We call him “Big Dave” to differentiate him from the Pragmatic Programmer of the same name.)

He gives a bit more background than has previously been told. Of particular interest to me is the role of “Big Dave” Thomas, the founder of OTI in kick-starting the organization.

I’m proud of my experiences working with and for “Big Dave” and to count him as a friend.

Posted in war_stories | Tags agilealliance, davethomas, oti | 1 comment | no trackbacks