Category: Humor

I’ve known a surprising number of developers who say, “Why use any higher level abstractions, you can just do this all in C, and the code will be cleaner and easier to read.” Sometimes, they’re right. Other times… not so much. And then there are the developers who find C too abstract for their tastes, and eschew things like structs.

That’s what Renee encountered when inheriting a chat server written in C. I’m guessing it was an IRC server, based on some terminology in the code.

bool channelexists[MAXCHANNELS];
char channelname[MAXCHANNELS][25];
char channeltopic[MAXCHANNELS][205];
char channeltopic_setby[MAXCHANNELS][50];
long channeltopic_settime[MAXCHANNELS];
bool channel_mode_registered[MAXCHANNELS];
bool channel_mode_onlyopstopic[MAXCHANNELS];
bool channel_mode_autovoice[MAXCHANNELS];
bool channel_mode_moderated[MAXCHANNELS];
bool channel_mode_private[MAXCHANNELS];
bool channel_mode_blockcolours[MAXCHANNELS];
bool channel_mode_inviteonly[MAXCHANNELS];
bool channel_mode_ircopsonly[MAXCHANNELS];
long channel_creationtime[MAXCHANNELS];
bool channel_bereitswho[MAXCHANNELS];
char channel_pw[MAXCHANNELS][CHANPWLEN + 1];
int channel_userlimit[MAXCHANNELS];
unsigned char channel_bans[MAXCHANNELS][MAXBANSPERCHAN][MAXUSERMASKLEN];
char channel_bans_actor[MAXCHANNELS][MAXBANSPERCHAN][50];
long channel_bans_time[MAXCHANNELS][MAXBANSPERCHAN];
int channel_invite[MAXCHANNELS][MAXINVITESPERCHAN];
long channel_invite_time[MAXCHANNELS][MAXINVITESPERCHAN];

This is an incomplete list of all of their global variables. These variables were allocated at application startup. There wasn’t a single dynamic memory allocation anywhere in the entire program, actually.

For some of these arrays, the index was the user ID. So, for example:

int useraddchan(int userid,int chanid,char isop) {
 int r;
 r = 0;
 while (r < MAXCHANSPERUSER) {
  if (client_inchannel[userid][r] < 0) {
   client_inchannel[userid][r] = chanid;
   client_inchannel_op[userid][r] = false;
   client_inchannel_hop[userid][r] = false;
   client_inchannel_voice[userid][r] = false;
   if (MAINTENANCEMODE == 0) {client_inchannel_admin[userid][r] =
isop;}else{client_inchannel_admin[userid][r] = false;}
   return;
  }
  r += 1;
 }
}

I really enjoy how this function doesn’t actually return a value on any code path. Really great.

And note that MAINTENANCEMODE flag.

#define MAINTENANCEMODE 0

If the server keeps crashing, you can recompile it in maintenance mode. I think that should be a “when“, frankly.

Search “house tour” on any video-sharing platform, and you’ll find millions of videos showcasing overwhelmingly large mansions, unique homes in the countryside, mountains, or other natural settings, and apartments built inside the most unlikely places, such as laundromats.

Yet, a woman named Dani Glaeze managed to capture everyone’s attention after sharing a video of her recently purchased home.

It’s a holiday in the US today, so as per tradition, we reach back through the archives. Today is a classic of code generation gone horribly, horribly wrong. Original. —Remy

It’s an old joke that Perl is a “write only language”. Despite some of its issues, back in the early 2000s, Perl was one of the best options out there for scripting languages and rapid-development automation.

Speaking of automation, build automation is really important. Back in the early 2000s, before Maven really caught on, your build automation tool for Java was Ant. Ant, like everything invented in the early 2000s, was driven by an XML scripting tool. Since it was tuned specifically for Java, it had some high-level operations to streamline tasks like generating proxy classes for calling web services based on a supplied WSDL file.

Actually, speaking of code generation, Carrie sends us this code block. It’s a Perl script that’s called from an Ant build. It runs after generating a class based off a WSDL. It parses Java code using Regular Expressions and injects a ListWrapper class which doesn’t adhere to the List contract. But hey, it does have a use strict declaration, guaranteeing you’ll get errors if you access uninitialized variables.

use strict;
use warnings;

my $dir = $ARGV[0];
readDir($dir);

sub readDir {
        my ($dir) = @_;
        opendir my $dirHandle, $dir or die "Cannot open $dir.n$!n";
        foreach my $file(readdir($dirHandle)) {
                next if $file =~ m/^./;

                if(-d "$dir/$file") {
                        readDir("$dir/$file");
                        next;
                }

                my %seenFields;
        my %multiples;

                my $fileName = "$dir/$file";

                open IN, "<$fileName" or die "Cannot open $fileName.n$!n";

                my @methods;

                my $file = "";
                my $currentLine;
                my $containsContent = 0;
                while() {
                        if($_ =~ m/@XmlElementRef(names*=s*"(.*?)".+namespaces*=s*"(.*?)".+types*=s*(.*?.class)/) {
                                my $field = ucfirst($1);
                my $namespace = $2;
                                my $class = $3;

                $multiples{$1}++;
                if($multiples{$field} > 1) {
                    $_ =~ s/names*=s*"$1"/name = "$1$multiples{$1}"/gis;
                    $field = $1 . $multiples{$1};
                }

                                my $fieldlc = lc($field);
                                my $retObject = substr($class, 0, length($class) - 6);
                                die if not defined $retObject;
                                my $methodName = $field;
                                unless(defined $seenFields{$methodName}) {
                                        $seenFields{$methodName} = 1;
                                        my $method = < 4) {
                                  className = className.substring(0, className.length() - 4);
                                  if(className.equalsIgnoreCase("$fieldlc")) {
                                          good = true;
                                  }
                          }
                  }
                  if(good) {
                                retVal.addWrapped(current);
                        }
                }
                return retVal;
        }

EOF
                                        push(@methods, $method);
                                }
                        } elsif ($_ =~ m/getContent()/) {
                                $containsContent = 1;
            }
                        $currentLine = $_;
                        $file .= $currentLine if defined $currentLine;
                }
                close IN;

                if($containsContent) {
                        print "$fileNamen";

                        for my $method(@methods) {
                                $file .= $method;
                        }

                        $file .= < extends ArrayList {
            private List contentsList;

            public ListWrapper(List contents) {
                super();
                contentsList = contents;
            }

            public boolean addWrapped(T toAdd) {
                return super.add(toAdd);
            }

            @Override
            public boolean add(T toAdd) {
                return contentsList.add(toAdd);
            }

            @Override
            public boolean addAll(java.util.Collection extends T> toAdd) {
                return contentsList.addAll(toAdd);
            }

            @Override
            public T set(int index, T element) {
                int realIndex = contentsList.indexOf(this.get(index));
                return (T)contentsList.set(realIndex, element);
            }
        }
}
EOF
                        open OUT, ">$fileName" or die "Cannot open $fileName.n$!n";
                        print OUT $file;
                        close OUT;
                }
        }
        closedir $dirHandle;
}

The corporate swamp is a vast, unending expanse of soul-crushing monotony and mind-numbing jargon. It’s a place where ambition goes to die, slowly suffocated by layers of bureaucracy and endless meetings that drain the will to live. Scroll down to see some of the best comics by @WorkChronicles Instagram account and have laugh through tears!