In my previous post, I wrote some code in Perl because I wanted the code to be clear and obvious. Wait? What? Who uses Perl when they want clarity?
Perl
I admit: I was surprised myself. Seriously, I tried several other languages first. Let’s just focus on the first loop here. Here’s the Perl again for reference:
foreach my $item ( @list_of_items ) {
$total += weight( $item );
}
Objective C
The actual code that I was attempting to explain was in Objective C with the NeXTStep foundation classes. I couldn’t imagine that anyone would want to try to understand it:
NSEnumerator* ee = [itemList objectEnumerator];
Item* item;
while ( ( item = (Item*)[ee nextObject] ) != nil ) {
total += [item weight];
}
C
My first attempt for the article was to write it in C using an array of items.
unsigned int ii;
for ( ii = 0; ii < itemCount; ++ii ) {
total += weight( itemArray[ ii ] );
}
That’s not too terrible. There is, however, a great deal of syntax and code devoted to handling the array including an extra variable to track its length. Beyond that, the loop counter is of little use to someone trying to understand the concept.
C++
My next go was C++. My hope was that iterators would make the looping less painful. C++ iterators, however, are the very model of pain.
std::list< Item* >::const_iterator it;
for ( it = itemList.begin(); it != itemList.end(); ++it ) {
total += weight( *it );
}
This requires the reader to wade through a syntactic thicket to get the iterator into the picture at all. It also requires a certain comfort with pointers that one wouldn’t have coming from another language.
Java
My next attempt was Java. I hate Java. It may not be terrible for this code with the new looping constructs that came in Java 1.5. Alas, I quit coding it before I made it through this first loop.
Lisp
Of course, I wanted to code this in Lisp:
...)
That would be perfectly clear to someone who has used Lisp or Scheme. Alas, not everyone has.
So… Perl…
If you want to write the Perl code, you have to understand the difference between scalars and arrays. To read the code, however, you don’t have to grok that distinction to see what’s going on. I didn’t try it in Python. Maybe it would be clear to a wider audience. I may have to try it next time.