How timely. Here's today's little gem:

sub _archive {
   my ($self, $store_file) = shift;
   
   # rest of code...
   
}
[download]

Not to forget its one true friend:

sub blah {
    my $arg = @_;
[download]

cheers

tachyon

s&&rsenoyhcatreve&&&s&n.+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print

I'll second this. :) I do it all the time too. The next most frequent one for me is forgetting to put "?" into regexp and then wondering why nothing was left of the input. ;)

Leonid Mamtchenkov aka TVSET

The end result was that rather than limiting which files got transferred to Bloomberg's ftp site, every file that they had ever been sent was resent. This was rather more than the receiving machine was prepared for, leading to crashing the machine which they use for receiving updates from partners.

The most that I can say to defend myself is that none of the programs involved were originally written by me, nor was I responsible for the overall fragile architecture. (It was just my job to keep things going and improving.)

The worst that I can say about this mistake is that while strict.pm would have caught it, this was not the incident that convinced me to use strict.pm. (But I should hasten to note that this was back in 5.003 when foreach my $foo (@list) was an illegal syntax. Which made strict.pm much more annoying to use than it is now.)

If you're in a position to hire or recommend anyone, please do not read this :)

My worst blunder was something like this:

my $sth = $dbh->prepare(<<'    END_SQL');
    UPDATE product_people_currency
    SET    people_id = ?
    WHERE  people_id = ?
    END_SQL

while (my ($old_id, $new_id) = each %id_pair) {
    $sth->execute($new_id,$old_id);
}
[download]

Naturally, the new id happened to match several old ids and the program happily reupdated them. However, because all IDs were valid, all of the tests passed and we ran this snippet against a production database. Our clients saw that the web site was still up and informed us that the "update" worked fine. It was weeks of bad emails going to their product contacts before they realized that it was the web site that was messed up.

Then I noticed that when the code detected the byte order of the 16-bit data, it was byte-swapping to big-endian when necessary, in order to get the numbers right -- on the sparc (which made them wrong on i686-linux). Oh well, it would only take a day or so to reconstitute those files... so the delivery would only be that much behind schedule.

Here's a couple of more that I remember.

When I was in college (back in the early 1980's), we were programming on a mainframe computer. When you compiled a program, it would generate a compile listing, which would contain the source of your program along with error messages. The compile listing would be displayed within the text editor. (You can see what's coming, can't you?) On more than one occassion, I would be looking at the compile listing, see my problem, make the correction to the source within the compile listing, and then be mystified as to why the problem was still there when I recompiled.

The other one that I remember involved setting some values in a hash, then trying to retrieve those values and coming up empty. The problem was, when the values were being set, the keys were ALL-CAPS, but when we were retrieving them, the keys were lower-case. I was pair-programming with someone and to this day, whenever we make a bone-headed programming mistake, we look at each other and say "Hashes are case sensitive!"

Your JavaJunkies looks nice. Out of curiosity, have you approached Sun to be your sponsor? It seems like it would interest them. Maybe they would give you your fast server.

Not strictly programming, but closely related:

I was working on the Everything Over Freenet project (now pretty much extinct) and was using CVS for the first time. I forgot to cd into my project directory and instead managed to import a significant chunk of my home dir onto SourceForge before I realized what I did. Naturally, this included my GnuPG keys. Then I got to find out how painful it is to attempt to delete files from CVS.

My brain is apparently blocking my own dumb errors, though I know I've made some, but none of mine top one from a predecessor at a former employer, a major PC manufacturer.

There was a subroutine which was supposed to adjust prices on certain items in certain circumstances; something to do with government contracts and pricing to the .1 cent level (yes, 1/10th of a cent).

Well, someone bozoed, something like = instead of += or adjusting the wrong variable, and was setting the price to a tenth of what it should be. And this somehow made it live. The "fix", which was in place when I came in, turned the whole subroutine into a no-op, by modifying one local variable and returning a different one.

A few years ago I needed to merge two directory trees with some pictures (don't ask ;~). There were some duplicates, some files that were only in one or the other tree, some files that had the same name but different content and so forth. So I started with a script that was supposed to browse those two trees and delete the real duplicates. Well ... gues what ... I inverted some condition by accident and started deleting the UNIQUE files. Oh my ... I did succeed to undelete some of the files, but quite a few have been lost :-(((

Such things really teach you to test things first :-}

P.S.: (Not Perl related and not really dumb ... or maybe yes, who knows.) A friend of mine was writing some school project in Pascal with TurboVision. And the program kept printing an error message "Null pointer assignment" when it was exiting. Some object was destroyed too soon or whatever. He could not find the error no matter what so he solved it differently. He made the program print "Made by " just before closing ;-)

Edit by castaway: Closed small tag in signature

It has, but good meditations are often revisited (not too often tough, once a year is enough).

MJD says "you can't just make shit up and expect the computer to know what you mean, retardo!"

I run a Win32 PPM repository for perl 5.6.x and 5.8.x -- I take requests (README).

** The third rule of perl club is a statement of fact: pod is sexy.

I worked in a call center that used an Aspect phone system. After working there for about 6 months, the Aspect programmer (who ran reports for management) and my manager approached me.

"Curtis, do you just never call any of your customers back?"

"Of course I do, what's this all about?"

After a little while of pleading my case, I got the programmer to run a custom report on all my call data without filtering anything, where my stats then looked the same as everyone else's.

As it turns out, our phone system let you omit the "1" on a long-distance call, which I figured out in my first week, so I was happily dialing one digit less on all my outbound calls. The programmer, who generated the reports on which some portion of an employee's job performance was determined, was grepping for phone calls in the database that matched a fixed length - 12 digits (9,1,then the 10 digit number).

That was quickly fixed, and it was determined that calls to local companies and international calls had never been considered in the past, either. However, I was the *only* employee to ever not dial a 1 for a long distance number. To help rectify that, I made sure to mention the shortcut dialing method to all of the new hires classes I trained.