I have to admit that I occasionally resort to goto myself. This week was one such an occasion. But before you pick up your torch and farming implement of choice and join the mob heading for my castle gates, please consider that  Dijkstra’s letter was complaining about unrestricted goto, which was a popular feature of languages at the time. It was an unstructured precursor of the subroutine and structured programming, which put goto on a leash and taught it not to bark at the neighbors. In restricting goto to local jumps, as most modern languages supporting the feature do, the beast became much less fearsome. In fact, a while loop is just a structured goto, as is try/catch (albeit with a little extra magic.)

Perl, of course, does not impose such restrictions on a programmer (although it does prohibit jumping into blocks that require initialization, such as other functions.) With a little discipline, though, goto is a feature and quite useful. It can be used to make extremely complex loops explicit and easy to follow as well as allow a loop to break to any outer loop in the current call stack.

As an example, I recently wrote a function to increment a string of arbitrary alphanumeric characters, where letters must maintain their case but increment as base-26 numbers and numbers increment normally (base 10). For example, if a letter increments past z, it becomes a and the next character to the left is then incremented. The increment logic fit into a function that took two of these strings and calculated all possible values in between to support some limited set operations against two alphanumeric ranges.

My original code for the increment logic was grisly at best. It took a series of nested while loops and state variables that were incremented or decremented as needed. I avoided recursion because the sequences were of arbitrary length. Breaking the code into subroutines made it more complex to maintain loop state. Using goto allowed me to break apart the logic into blocks without the overhead or state-passing necessary to shoehorn the logic into subroutines. I was able to label each part clearly and jump between them as needed to increment or “carry the 1.” I reduced the size of the code to just a couple dozen lines, including safety checks, and found that the goto code was much easier to read and reason about.

That said, I want to emphasize strongly that goto should be kept local. Jumping to outer function calls makes the logic of a program difficult to reason about and changes scope in confusing ways. But as a way of structuring complex loops and iterative logic, you just can’t beat goto.

Submit article

It does have its big selling point, enumerable. Enumerable is nice. Blocks are nice, although they are not as powerful as lambdas. One big selling point that you rarely see mentioned, though, is Perl-style regexp.

Nearly every language can do regular expression matching using Perl-style regular expressions. However, few have built-in operators for it – =~ to match an expression and s/foo/bar to modify an expression. PHP’s functions, by comparison, are a huge code overhead. The same is true for Python. For example, in PHP:

$x = "hello world";
$x = preg_replace("/world/", "Jeff");

…not to mention having to first import the regex library into Python:

import re
regex = re.compile('world')
x = "hello world"
x = regex.sub("Jeff", x)

Whereas in Perl you just have:

$x = "hello world";
$x =~ s/world/Jeff/;

Ruby has similar syntax and a powerful regexp library. It also has Perl’s syntactic freedom – that is, things can be written in many different ways.

i = "Hello world"
if i == "Hello world"
    puts i
end

or…

puts i if i == "Hello world"

Functions also do not require parenthesis if the meaning is clear:

puts(i)

or…

puts i

This is often called “poetry mode” by Rubyists. However, few Rubyists like to compare their language with Perl because Ruby is religiously object oriented, and Perl is more of an example on how not to implement OOP.

But Ruby does have its origins in Perl. It inherits a lot of features from languages like Smalltalk and lisp, but if you look at a large Ruby program, you begin to see how Perl-like it is.

And that is Ruby’s biggest problem as well. As with Perl, syntactic freedom means that the neatness of code is often a product of the mood of the programmer or the deadline. Coming back to a program after six months can mean hours of analyzing code, trying to figure out what on earth you were thinking when you wrote that.

Submit article