Duck Interface

Perhaps I was being naive but I never expected quite the chatter that my post on HumaneInterface opened up. Sadly most of it ended up being arguments about the relative merits of Ruby's Array and Java's List rather than the underlying points I was trying to make, but despite that I think some nice conversational tributaries appeared.

(Although I feel I ought to point out that it wasn't my intention to say that I thought that Ruby's Array was better or indeed that Ruby is better - I don't think either is better than the other unless you give more context. As it turns out I like both Ruby's Array and Java's List, although they are designed quite differently. Like any software they are flawed, since nobody writes classes that are exactly the way I want them this minute, but I wouldn't like to pit any of my code against them. The point is they are both useful and I use them both a lot - which is why they came to mind as an example.)

One of these conversational threads brought out that there are other reasons for the differences between Array and List than the humane/minimal philosophies. One of these reasons has to do with the way similar functionality plays different roles in the two languages.

Ruby's Array has a number of methods that made a few people puzzled when the looked at the list. Push and pop - as Elliotte said “Someone pushed a stack into the list”. There's also shift and unshift which are like a list. This doesn't look right - Elliotte again “if you're using a queue or a stack, shouldn't you use a Queue or Stack class rather a List class?”

Reading this triggered a thought in one of the recesses of my memory. I dug out Smalltalk Best Practice Patterns, a fantastic book that anyone who seriously wants to understand object-orientation should read (despite the funny syntax).

“One of the first objects many people write when they come to Smalltalk is Stack. Stack is the basic data structure, fabled in song, story, and hundreds of papers about theoretical programming languages... there is no Stack class in any of the basic images. I've seen one written any number of times, but they never seem to last long.”

-- Kent Beck

The smalltalker approach, at least then, was to use OrderedCollection, Smalltalk's equivalent of Ruby's Array. There wasn't even a push or pop - instead Kent showed using addLast: and removeLast:.

Kent didn't give an explanation for the lack or a stack (and queue) - “Why is there no Stack in Smalltalk? Well, 'just because'. It is part of the culture to simulate stacks using OrderedCollection.”

I'm not sure how I feel about this (and I get the distinct impression of uncertainty in Kent's writing). If you are going to use something like a queue it does make sense to say Stack new rather than OrderedCollection new, let alone use push and pop rather than addLast and removeLast.

It strikes me that part of this situation may be to do with the difference between static and dynamic languages. Static languages like to talk to objects through strict type interfaces, dynamic languages have classes that can fit multiple roles - Duck Typing. Java also has a list that does double duty as a queue: LinkedList, but you'd typically use it through distinct interfaces not realizing the common implementation. The Smalltalk feeling is that we can get what we want with our OrderedCollection, so why build another class? Ruby seems to be echoing that reaction and adding the meaningful method names for people who use it in that context. (Although to be fair I have no idea whether the rubyists actually are happy with Array being a stack, or whether it's a piece of regretful legacy.)

Another factor is what the language encourages for implementing these structures. As Charles Miller said “Java's design affords small interfaces, and utility functions provided as static methods on helper classes. Ruby's design affords larger classes with mixed-in utility methods.”

Perhaps one of the conclusions from this is that we should be wary of judging the features of a class in one language using the values of another language. Is Array the equivalent of List or of List plus various interfaces and implementations in the collections package - or is it something even more complicated? Some people might recoil from the thought of doing 78 things to a list, but I suspect lispers would think of many more to add. Ruby's Array has it's warts, but I must admit I like working with it more than the Java collections, although how much this is due to the humane interface guidelines and how much due to Ruby syntactic support I'm not sure.

All in all I'm not sure who I agree with here, or whether it really matters that much. Like with many of these arguments I think the most interesting thing is to try to understand both points of view.