He put the @ in email:

The symbol suggests that we think of the web as a geographic location, rather than a state of mind. It is something to be surfed, cruised, crawled through.

Reading the development docs that Apple provide for Objective-c I’ve twice come across this definition of Polymorphism, or something like it;

… two objects can respond differently to the same message. For example, each kind of object that receives a display message could display itself in a unique way. A Circle and a Rectangle would respond differently to identical instructions to track the cursor.

This feature, referred to as polymorphism, plays a significant role in the design of object-oriented programs. Together with dynamic binding, it permits you to write code that might apply to any number of different kinds of objects, without you having to choose at the time you write the code what kinds of objects they might be. They might even be objects that will be developed later, by other programmers working on other projects. If you write code that sends a display message to an id variable, any object that has a display method is a potential receiver.

Well, OK, at a basic level, I guess. It’s saying that a method, e.g. draw() will behave differently in its implementation on type Circle to type Rectangle. And that perhaps a different programmer could supply a different Shape object that has another different draw() method.

But am I alone in thinking that while the above actually may be strictly subtype polymorphism, it’s not really the interesting point of its programatically expressive power. The above just sounds like inheritance combined with method overriding. Polymorphism isn’t just inheritance! Just to exclude things like parametric polymorphism (aka generics), and method overloadingfor a moment.

For me; polymorphism at its most basic (i.e. subtype polymorphism), derives from something like this;

interface Circle extends Drawable, TwoD, HasCanvas {
  // from Drawable
  void draw();
 
  // from TwoD
  HeightWidth getDimensions();
 
  // from HasCanvas
  Canvas getCanvas();
  void setCanvas(Canvas canvas);
}
 
interface Pencil extends DrawingInstrument, SharpenIt {
  void draw(Drawable thingToDraw);
  void surfaceToDraw(HasCanvas hasCanvas);
  void sharpenIt();
}

For me, the real key to polymorphism is that a single type can have multiple interfaces, i.e. that the Circle above, can in one circumstance, look like a ‘Drawable’, and in another, a ‘HasCanvas’, and not that there might be multiple implementation of either ‘Drawable’ and ‘HasCanvas’, etc … which just describes inheritance, if you ask me.

Tell me I’m wrong. Maybe its just because the Objective-C document is trying to slowly introduce these concepts to people only used to C?

As everyone knows, the organization’s IT infrastructure has to be business-driven. Except for one challenge: It will last longer than any of the business plans that drive it.

Bob Lewis on infrastructure in business. Now just as we were discussing this our system admin was walking by and he said “If your infrastructure is 10 years old you should be sacked.” … we shot back, what about Oracle databases? Plenty of places run an old version of their database and are terrified of the disruption to upgrade. In fact often sometimes the hardware is upgraded multiple times without changing the server software platforms significantly. All those 10g and 11g SOA Suites and Weblogic installations that just went in over the past few years (and 10g is from 2003 so its nearly a decade old already!). How long with they last? How about Windows XP … Office 2003 … Exchange … All this stuff is on some level ‘infrastructure’. And generally it’s a drag on your business strategy because it was installed to conform with your strategic direction two strategies ago.