Perl Really Sucks (And They Don’t Even Realize It!)

Perladmin takes the bait: Why “Perl Sucks” examples are always so funny is a response to my post Python Rocks (Perl Sucks).

He pretends like I’ve never heard of splice. Of course I’ve heard of splice. I’ve heard of all the functions, because I’ve read the perl man pages and reference books multiple times. It’s my job. I know perl better than anyone I know. And I work at a pretty big company with lots of very smart perl people. (I met Larry Wall once, but I can’t say that I know him, so he doesn’t count.)

But he misses the point.

Well, he got the point that I am obviously biased, in the same way a boy falls madly in love with a girl. But it isn’t blind love. I know python and perl well, too well, and I choose python.

First, let me answer a question he had:

In the Python example the variable group is an array data type so it doesn’t need de-referencing because its not a pointer. (Ahem!) Perhaps internally it is, (Good guess) and Python only has references and all functions know how to work with them. Good news for Python if it is. (Yep! Yep! Yep!) But if you’re using arrays in your Python script, you have to make an apples-to-apples (I just did.) comparison with Perl, in which case your variable is @group, and the variable doesn’t need de-referencing, thus we also resolve this issue.

The closest thing in perl to a python variable is the scalar. In fact, it is safe to say that in Python, all variables are the same thing as refs in perl. So, $group in perl is group in Python, provided that $group is a reference. (To what? It doesn’t matter.)

Now, he took several pages to try and justify perl’s existence. I will smash him with one simple point:

HE TOOK SEVERAL PAGES TO TRY AND JUSTIFY PERL’S EXISTENCE.

And in the end, this is the code he came up with, writting in perl and then python. Note that he forgets that $group and $maxNumInSubgroup may be expressions, not actual arrays. If that were the case, then you’d have to assign the expressions into $group and $maxNumInSubgroup rather than express it naturally in context.

Oh, and the #$group crap? Yeah, that refers to the @group, not $group. Got it? Don’t worry, it’s an interview question. If you see code like this in perl, you rewrite it the way I wrote it in my article so that mere mortals can understand it.

# perl
my @group = @{$group}; # Dereference, then array copy
my @subgroup = @group[0..(#$group > $maxNumInSubgroup ? $maxNumInSubgroup : #$group)];

# Python (equivalent)
group2 = group1[:] # dereference (no can do in Python!) then array copy
subgroup = group[:len(group2) > maxNumInSubgroup ? maxNumInSubgroup : len(group2)]

# Python (natural)
subgroup = group[:maxNumInSubgroup]

And he dares say:

The above end-result for the Perl code is slightly longer, but no less readable.

I pause now to allow you to clean your keyboards, catch your breath, lower your heart rate after the good belly laugh you enjoyed. Or not. Because he’s completely serious. He actually believes what he wrote, folks.

In the end, he discovered that perl’s splice and Python’s slice are two different things. See, perl’s splice changes the array being spliced. And Python’s slice, makes a new array copied from the old one. That’s a fundamental design decision.

But he mentions speed and performance. See, when you do a copy & splice in perl, you are wasting valuable time and memory. Part of that time is spent trying to remember which arguments to splice do what, and the other part is spent remembering that splice doesn’t do slice. The rest of the wasted time is spent typing it up and trying to remember that dereference @ binds more tightly than ->, so you have to put {} around the thing.

Oh yeah, and you waste some CPU and RAM as well, but who cares about that anymore?

Question: Which use case is more common?
Answer: Perl copy & splice, which is Python slice.

Question: Does Python even have splice capability?
Answer: Of course. del a[i:j] and a[i:j] = [...].

Question: Why doesn’t perl have a slice function? I mean, it’s a pretty common use case, and HOW HARD CAN IT BE TO ADD THE THING?
Answer: Stop shouting!

Other interesting things…

In fairness I should point out that the above examples would generate warnings under strict type checking. I have no idea if Python has an equivalent. If it doesn’t I would think that it is a hinderence to Python developers.

N.B what Python does vs. perl. You actually have to run this code to see why Python doesn’t need “use strict”. If you don’t run the code, you won’t understand what it does unless you already know Python and perl.

# A: perl
use strict;
print $foo;

# A: python
print foo

# B: perl
use strict;
my $foo = "bar";
print $foo;

# B: Python
foo = "bar"
print foo

If that’s too hard for you perl-gods to comprehend, let me interpret. Python’s assign is a declare and assign. That is, the “my” is hidden somewhere, obscured, forever banished. Python scoping rules are quite different than perl’s, eliminating the dynamic scope (aka, what “local” gives you) and relying only on lexical and calling scope (aka, what “my” gives you.) So we don’t need “my”, just like we don’t need @, %, $, or &, *, or anything else like that since there is only one kind of variable.

Now, as a serious aside, let me be bold in admitting that Python isn’t perfect. But it’s a world apart from perl. Heck, even Ruby kicks perl’s butt up and down the street, and Ruby sucks pretty bad too, in very serious and bad ways. When it gets right down to it, Python has some serious issues as well, but I consider them warts and not life-threatening cancers.

Perl was great, groundbreaking, revolutionary stuff in its time. My hat’s off to Larry Wall and the perl community who took on the programming language industry and won. But the victory celebration is long over and we’ve moved on with our lives to new and better fields. So has the perl community, at least most of it.