NullPointerFactory

For a while now I thought that after a few more years as an engineer I’d try to become an instructor or an evangelist of some kind. At every class, symposium, or product launch I attended, I kept thinking how great it must be to be one of those people on the other side of the podium. Traveling around, meeting new people… it all seems like a bright contrast to coming into the same cubicle and the same people every day, however great those people and that cubicle may be. Besides, I adore PowerPoint with a burning passion… it’s a love affair I carry since junior high… I always got a kick out of doing presentations ever since I stopped sweating from stage fright in front of a classroom. As of three days ago, a shadow of doubt overcast this ambition.

This past Thursday I did a presentation in front of a group of complete strangers. To be sure, I made many mistakes that I will not repeat:

• Taking a presentation designed for one audience and transposing it onto a different audience without adjusting for the difference in the audience’s background and context. A critical step in the preparation of any human-oriented deliverable, be it a presentation, a document, or even a piece of software, is to become one with the audience: to learn what the audience knows, and to forget what it doesn’t know.
   
• Failure to pre-designate “martyrs”. A “martyr” is what I call a topic area that will be sacrificed if the presentation becomes slowed due to audience participation or the need to dwell on or clarify another point. Once identified, martyr topics together with martyr slides must be moved toward the end of the presentation while, hopefully, maintaining some semblance of a coherent narrative.

• Failure to wrap quickly when I noticed the audience interest wavering. Some nugget of information at the end just seemed to interesting to chop it off. It’s a challenging balance between wanting to end with a bang, and slipping the martyrs toward the end where they can be quickly done away with.

But there’s one truth that will remain in spite of how good a presenter I become… At work, I have a very warm, jovial relationship with all of my colleagues. Anyone who’s known me for longer than five minutes knows that I have no qualms about sacrificing my dignity to elicit a laugh, and so in a familiar environment all sorts of little gags and self-deprecating kernels of insanity are allowed and welcome… that’s what makes it fun. In front of strangers, however, this just does not work… they can’t tell if I’m goofing off or if I should be taken away by men in white suits… In a technical presentation, people expect distilled technical content - everything else, is a distraction. That took some air out of me.

There are exceptions, I think. Keynotes and meta-technical presentations allow room for some occasional frolic. When audience members don’t exactly know what they came to hear, they’ll grant much more leeway. Also, I noted earlier my failure to develop more common ground with the audience in advance of the talk. Perhaps on that common ground, some seeds of amusement may blossom. In the meanwhile, the only answer is to try again…

Disclaimer: Opinions expressed in this blog in general and this post in particular are my own, and may not reflect the opinions of my employer(s), ISP(s), friends, family, pets (if any), romantic partners (if any), etc.

Today I’m going to dwell on something other than programming, though like a well-trained homing pidgeon, I’ll quickly find my way back. Lots of talk about China and Tibet these days - the spotlight on Tibet seems brighter than any time in recent history. It is easy and oh-so-tempting to decry a forced occupation, to swell up in anger over alleged destruction of an ancient heritage… But what is right and wrong?

I believe principles and morals should be firm - they shouldn’t change from one context to the next. Of course they need to be complex enough to reflect and accomodate various nuances in situations, but the methods by which we label something right or wrong should be invariant. In other words, we should be able to represent morality as a function in say, Java (not Ruby where a function could be one thing today and another thing tomorrow). It would look something like this:

public static bool isMoral(Circumstance[ ] something);

The obvious choice would be something along the lines of “forced occupation of an unwilling people is immoral”. Ok, let’s put it through some test cases. Occupation of Tibet? Looks like a no-no. A hypothetical invasion of Taiwan? Ditto. How about the forced retention of the Confederate states in the U.S. Civil War? Most Americans consider the Civil War one of our nation’s brightest moments - we’d expect a true here. After all, the Confederates had slavery! Ok, so do we change our function to be “forced occupation of an unwilling people is immoral unless they’re engaged in a highly-immoral practice”? Well, for starters we now have a recursive call to the isMoral function…

Perhaps some base case can be defined, broken down into finite weighted critera - and yours will probably oh-so-slightly from mine… but that’s not my point. I would suggest that we all take a test-driven approach. Before accepting any morality-based assertion, try to apply the same morality function to every other case, past or present, real or hypothetical, that you can think of.

We agree the colonization of North America at the expense of the native peoples was immoral and we’ve made some ammends, but we didn’t leave, did we? So perhaps aside from the isMoral function, there’s also an isAcceptable function. And this one could benefit from some TDD too… from historical test cases, it seems that it is not acceptable to attend the 1980 olympics in Moscow over the Soviet invasion of Afghanistan to fight the Taliban and Osama bin Laden, but it is acceptable to attend the 1936 olympics in Berlin, in Nazi Germany… Clearly to enough people both seemed acceptable at the time. Unlike morality, acceptability seems more like a Ruby function than a Java one - this today, that tomorrow.

So if we consider the present-day outcome of the North-American colonization acceptable, regardless of morality, the Tibet occupation might have an acceptable outcome too. Perhaps, the global attention and a strong desire for resolution could allow for an agreement that includes both occupation and socio-cultural preservation. Many people’s isMoral functions would balk, but perhaps the majority of the world’s isAcceptable functions could eventually return true.

Remember that moment in The Sound of Music where Captain Von Trapp first joins in singing with his children? That instant when he realizes just how much he’s been missing, and suddenly it all comes back? I had one of those moments at the No Fluff Just Stuff in Boston a couple of days ago…

It was during Neal Ford’s presentation on patterns in dynamic languages… I remembered my Structure and Interpretation of Computer Programs class… you know, the one in Scheme/Lisp with the wizard book? I thought of the time when we studied the metacircular evaluators and compilers and realized that since then (certainly since I graduated college), I’ve never had to twist my brain into such fine knots to wrap around a new paradigm. Sure, there’s always a challenge - how to best model and design a solution, but never such a fundamental shift… And now, seeing classes that morph and expand themselves, a simultaneous celebration and violation of object-oriented thought… it was like a reunion with my long-lost wizard friends.

I’m not about to become a Ruby convert. I believe static typing is an essential feature and should be sacrificed only when the resulting gains are truly substantial (Ted Neward, another excellent speaker from the NFJS circuit, agrees). It’s the different thought process that made my day. After my one semester with the wizards, I went back to learning and thinking in Java, wondering oh-so-briefly why it didn’t let me pass functions to functions. Soon I stopped wondering and life moved on. I ended up in a cerebral rut… Even living up by the Pragmatic Programmers’ “learn a new language each year” rule, I was learning another syntax with cool features nothing more… Even discovering closures in Groovy and and delegates in C# was not quite all that big, because features alone only stretch one’s knowledge. Ideas stretch one’s thinking.

It’s hard to get out of a rut when you’re in one… (A) because you may not realize it, since what you have gets the job done, and (B) after a day of contentedly programming in the same style all day at work, one wants to be with family/friends/boyfriend/girlfriend or to pursue non-programming interests… I think this, more than anything else, is the prime value of books, blogs, and conferences like No Fluff Just Stuff - to provide the much needed red pill to rut dwellers like myself. Paradigm shifts are brain candy. Go ahead, indulge yourself.

Still at NFJS, and even when I go home, I keep thinking about Neal Ford’s keynote that I railed about a couple of days ago. So maybe complexity, or at least complexity that is not related to problems we’re trying to solve (”ceremonial” complexity, as Neal calls it), isn’t costing us jobs. But is it costing us sleep? nerves? I don’t think I, or anyone else, could disagree that “ceremonial complexity” is the enemy… and then I think back to another talk by Neal Ford during the conference, and his mention that the “new languages” are not about static typing vs. dynamic typing… it’s “ceremony vs. essence”. Neal uses Scala as an example (one that is, sadly, unfamiliar to me) of a static language that provides power without ceremony. This I can live with - static typing isn’t the enemy. Ceremonial complexity is.

So the question is, do we need to brush aside static typing, simply because its greatest harbinger, Java, appears to many to be beyond saving? For me personally, it’s just too great a feature to sacrifice. And more importantly, there’s no need to. There are currently several different proposoals for closures in Java, and reasonable hope to see them someday. C#’s delegates already offer something in that spirit, albeit in a slightly more verbose incarnation. C# 3.0’s lambda expressions go a long way in trimming the fat.

There are other features of C# that resemble those of popular dynamic languages. C# 3.0’s extension methods let you add methods to existing classes, even if they’re final. C# good old features, such as indexers and property go a long way in making the language less like Java and more like Groovy. But there is still more that can be done. Why not add a compiler trick where invocation of an unexistant method will call MethodMissing(string invokedMethodName, object[] arguments)… Have MethodMissing be an event on System.Object - if there’s a handler for it, with the above signature, use it! If not, puke! Let the user choose whether to puke at compile time or at runtime with a compiler switch.

There are probably holes somewhere in the preceding paragraph - I’m designing out of my a** here. But my point is, we should not give up on static languages… I know, I won’t. Having gone from Java to C#, I have seen how much can be accomplished if the driving force behind the language isn’t mired in bureaucracy.

There is probably more ranting on “ceremonial complexity” left to be done, an inquiry into how the hunt for flexibility can bring about bloat (see WebSphere) or freedom (see any language with closures). The important thing for now is that, having found a common enemy, dynamic people and static people can at last be friends.

Back from day 1 of the conference. Here’s the raw, unedited, and uncensored rant.

First the good: all the speakers I heard today were very strong. This is not to say that I agree with all of them on all counts (more on this in a bit), but rather that their delivery was effective, and their material - enlightening and/or thought-provoking. Jared Richardson’s talk titled “Build Teams, not Products,” in particular, was one of the best presentations I’ve ever witnessed. It was just one of those talks where all the points seem tautological and obvious, until you consider how many (or rather, how few) you apply to your own work. I couldn’t come close to doing the talk justice by summarizing it here - if you can, hear it for yourself.

Another striking highlight was the manner and style of Neal Ford’s keynote. Very stirring, very effective. Mr. Ford clearly graduated the Steve Jobs school of presentations with the highest honors.

Ok, that’s enough ra-ra’s for one day. The time for complaining is nigh… Mr. Ford’s keynote, since we’re already on the subject, although excellently crafted and delivered, raises questions at best. Although entitled “Ancient Philosophers and Blowhard Jamborees“, the talk can be summarized in a sentence as “WebSphere and Rational ClearCase are causing our jobs to be outsourced to Chindia… permanently”. Our industry, as Mr. Ford, would have it, is crippled by the Svengali vendors of gargantuan and deleterious middleware, that renders us unable to compete with the likes of India and China. Really, Neal, WebSphere? Is WebSphere responsible for the 32% decline in the number of Comp. Sci majors in the U.S. from 2000 to 2004? Is WebSphere the reason why Bill Gates begged Congress to increase the number of work visas to the states? Or maybe SOAP is responsible for the war in Iraq? Perhaps CORBA brought about the current recession?

Don’t get me wrong - I’m no fan of WebSphere, and I loathe ClearCase with a burning passion (ask my manager!) Yet it seems obvious to me that there are far greater factors to explain our shrinking I.T. industry than its subservience to the mean, ugly middleware vendors. Is there vendor-induced inefficiency in I.T? Sure. But no argument in Neal’s keynote demonstrates that (A) this inefficiency does not exist in “Chindia”, and (B) when the “Chindian” companies start posing a threat to their American competitors due some gap in IT efficiency, that American business won’t rise to occasion. And for heaven’s sake, if you’re going to show a cruise ship to characterize a bloated piece of architecture, use the Freedom of the Seas, not the Carnival Conquest, which is lighter by about 40,000 tons and fits about 1500 fewer passengers. Hey, I’m a cruise ship fanatic, I couldn’t help myself.

The talk on meta-programming in Groovy with Jeff Brown was quite well done, but left one major unanswered question: all these closure delegates and meta-classes - if one is not building or using an internal DSL, what do they offer that a static language does not? The ability to stick a parameter into a method name instead of an argument? Don’t get me wrong - I really like Groovy, including the metaprogramming features. What angers me is seeing a couple of features that are useful within one specific domain (DSLs) touted as the death knell for Java, C# and the like… with a few compiler tricks and reflection/emission constructs, a static language could satisfy most meta-programming needs. C# 3.0 is well on the right path.

But just so I don’t end on a negative note, there’s one more thing that really impressed me today: the dessert selection at dinner featured these incredible soft brown pastries that I have so far seen in only three palces: Russia, Russian stores in the U.S., and on the M/S Noordam. Sampling them again today was a true pleasure.

To be continued…