The Daily WTF

Strings in C remain hard. They're complicated- they're complicated because of null termination, they're complicated because of memory management, they're complicated because of the behaviors of const. There's a lot going on in C strings.But Alice had a simple case: convert a true or false value into the string "true" or "false". Let's see how her co-worker solved this:

The list of things never to write yourself contains some obvious stars: don't write your own date handling, your own encryption, your own authentication/authorization. It's not that no one should write these things, it's that these domains all are very complicated, require a great deal of specialized knowledge, and while easy to get almost correct, they're nearly impossible to get actually correct. If you embark on these tasks, it's because you want to create a product that solves these problems, hopefully not because you've got a terminal case of NIH syndrome.While it's not as big a star on the list, another domain you probably shouldn't try and solve yourself is logging. Today's anonymous submission isn't the worst home-grown logging I can imagine, but it's got enough bad choices in it to merit some analysis.

Sami inherited some C# LINQ code. The actual behavior and purpose of this code is fairly simple. The way the code was written, however, well…

We received a surfeit of submissions this week. The choices below were selected almost at random, but coincidentally two of them were sent in by regular reader Michael R. to start things off.Said Michael "Reading CodeSOD on 2023-05-15 made me brush up my knowledgeof log. Little did I know that it comes with its owndefects. Thank you Google."If you were a mathematician, and wanted to build a wooden table,what else would you use?

I've said many unkind things about ASP.Net WebForms in the past. While it leaves a lot to be desired as a web development environment, its event driven approach does map to a lot of folks understanding of software. Click a button, execute code in response. Change a radio button, execute code in response. A simple, easy to understand architecture.Well, sometimes simple and easy to understand.A number of years ago, Kyle was tasked with updating his employer's "benefits election" site for the new year, and found this:

Krzysztof found themselves staring at a C++ function called intToString. And staring. And then realized that the function makes more sense if you don't look at the name. Let's take a peek:

Normally, I wouldn't have much to say about a simple "it's a mere arithmetic error" type of code sample. But this submission from Taylor adds an important factor: it's a basic arithmetic mistake in date handling code, in a legacy product that's been in use for decades. Oh, and it's written in Delphi.

Denise was supervising a developer who encountered a difficult problem: string handling in C. It's not particularly fun to work with strings in C, but it's certainly feasible.One of the key issues for strings is that you need to know how large the string is going to be so you can allocate a buffer for it. And while there's a strlen, there is no intlen, so when you want to turn a number into a string, you're faced with a branching path.The first path, would be to simply remember your logarithms from high school and know that the log10 of a number tells you how many digits (in base 10) it holds.The second path would be to learn how to use the printf family of functions, and let the C standard solve that problem for you.The third path would be to do this:

Friday comes but once a week, so perhaps you should read this column very very slowly to make it last.Disoriented David declared "I legitimately was confused while reading this because I got my days of theweek mixed up. Too bad they couldn't tell me."

Emma X maintains some software for a company that does mechanical engineering. In this specific case, her software needs to match a part on their equipment to a tube which can hold the part. They're operating on the order of millimeters, so the smallest tube is about 8mm, and the largest is 155mm.Now, obviously, not every possible millimeter size is possible- from 8mm to 58mm, the possible diameters all proceed at a step of 2mm. Between 60mm and 95mm, the step is 5mm, and between 100 and 150, the step is 10mm. As I describe this problem, you're probably imagining a lookup table of some kind, or maybe just a list of possible diameters generated by for loops or some similar construct. If that were how this worked, the code wouldn't be there.

Ellen sends us a very simple WTF today, that she found in production code.

Jeremy found this VB.Net code. It has a simple job: return a file back to the client, but with a twist: they don't know what the correct file extension is. So this was their solution for that problem:

Many years ago, Matt left a position where he developed in FORTRAN, and went off to do other things. The company hired a replacement, and since no one else really understood FORTRAN, they assumed things were fine. Over the course of a decade, their development costs got more expensive, their software got buggier, and deadlines started flying by without a single new feature being released. It took a long time, but they eventually fired Matt's replacement. Since Matt was looking for a new position around that time, he ended up back in the FORTRAN shop: just when he thought he was out, they pulled him back in.Matt started going through the code that'd been implemented, and… well, here's an example function signature:

With your weekly dose of snark, and just one execrable pun, here follows Error'd:A reader who asked to remainVery Anonymous sent us this suicide note for his reputation."Somehow, lyrics.com could get the right photo (fromWikipedia, it seems) of the country singer StonewallJackson, but ended up with the Confederate general's bio.PS: Please don't ask or judge me as to why I was looking for the lyrics toJesus Took The Outlaw Out Of Me." I'm sure we really don't want to know.

Python is a language underpinned by a philosophy about how programming should work. It's opinionated. As a result, in the Python world, you'll hear constant debates over what is and is not "Pythonic", and you'll encounter all the weird ways in which the Python philosophy and real-world programming needs conflict: for example, you don't use switch statements in Python, you put callable functions in a dict instead.I bring that case up, specifically, because Python's philosophy is that there should be one correct way to do everything: since if statements handle branches, switch statements are unnecessary. Ternaries are also unnecessary by that rule- but they exist and Python has its own twist on them.In Python, you can do something like:

Sandra has ongoing issues. When we last checked in, we had some problems with geography, and those problems haven't been solved.Now, one truth of geographic points is that they're bounded. We know, for example, that longitudes cover the range (-180,180), and latitudes are always (-90,90). Even if we change the coordinate system, it will still have bounds, as the Earth is a closed shape with finite boundaries.Sandra maintains an application that lets users annotate the map with their own data points, drawing shapes on the map and recording the coordinates of the shape. The code which manages the map layer allows the user to pan around the map, and transparently update its internal coordinates to remain within those boundaries. The code which manages the annotation layer, however, does not. It will happily let you draw a shape on New Zealand, and the coordinates might be 177 degrees, -183 degrees, or even -543 degrees. It doesn't care.Now, when exporting this data, this turns out not to be a problem. Other mapping tools will receive a wildly out of bounds coordinate and shift it into the valid range- a safe and non-destructive operation.But when rendering the data, it turns out, it's a problem. The annotation layer isn't smart enough to do that shifting, so if you scroll around the map a few times, and draw a shape on New Zealand at, say, -543 degrees, the next time you load the data and scroll to New Zealand- your annotations aren't there. But if you rotate around the Earth a few times, like Superman reversing time, the annotations will pop up.The end result is a lot of very confused users, and a lot of support tickets that basically amount to "you rotated the Earth wrong, try again".The fix would be some relatively simple math, but as is frequently with the case with these things, the annotation layer code is a mass of ugly spaghetti and every change is fraught with risk. There are also a million other things on fire, which means, "users get confused but their data still exists" places it on the absolute lowest priority. So the tickets keep coming, the users keep getting unsatisfactory workarounds, the world keeps spinning, and nothing ever changes. [Advertisement] Keep the plebs out of prod. Restrict NuGet feed privileges with ProGet. Learn more.

Tony works in a shop that makes extensive use of XMLDocs comments. Now, it's no surprise that many of the comments take the form:

Jeremy was sent hunting a bug in some older JavaScript code. The key problem was that many phone numbers were getting a US country code prepended to them, even when they already had a different country code and were in a different country than the US.

A couple of mojibakes and onlyone really awful pun this week. This editor was in Texas for the week and just can't escape the John Wayne references.Long-time listener, first-time callerBruno shared his first submission after 20 years and ran into abit of a hitch, which we're saving for a special episode. But here's his historic snark:"It's not that often that we see errors in Big Name Games on TDWTF.Well, the lastest heir to the Borderlands series of games is Tiny Tina Wonderland, and it delivers.Of course, it also delivers a way to optimize your inventory, because that's in the Borderlands genes.However, this was an [endgamebold] first: I still kept the legendary, sorry ;-)" Thanks, Bruno!

Jon sends us an entire function, but I'm just going start with the comment, after which you'll understand everything bad about this without me explaining further. Don't worry, I will, but the comment says it all:

What makes code bad? Is it an inherent property of the code itself? Or is it the context in which the code is placed?For example, let's look at this function, found by Lars.

Sometimes, you go up to the fridge, looking for a snack, and see the array of leftovers, and your appetite fails you. You want to eat, you know you have plenty of options that you just need to throw into the microwave, but none of them look appetizing. Leftovers always seem like a better idea when you're busy making them than when you're trying to deal with them after the fact.Stev's co-worker has left them a large pile of leftovers. This block is representative of all the half-finished leftovers that don't do anything and shouldn't be there, but happily make it much harder to understand the codebase:

There was an era, briefly, where corporations flirted with the idea of replacing their web based UIs with Flash. There were even UI frameworks, like Flex, built to support that kind of migration. Yes, it was a disaster.But not quite as much of a disaster as this action script code that Daniel found. At some point, someone at Initech decided they needed to implement a random number generator. This is what they came up with:

NaaN stands for NaN Ain't A Number. But other things most certainly are,even though we don't always think of them as numbers or represent them as decimals. MCMLXVI, for example.Sometimes zero. Maybe even more so 5-i. This week we have some specialnumbers for you, among other things.Lonely dog-lover Kevin M. was thrown from joy to despair in barely one second."Embark found some new relatives for my dog... or not." It's arguablytechnically true that Embark found a number of new pup kin.

Matt is supporting an old VB.Net application. This representative line highlights the overall code quality:

Paulette's team had built a wrapper method around the C# authentication APIs that acted as a convenience function. Called GetAuthenticationProvider, it accepted two parameters. The first, a string, could be used to look up the provider's type in a lookup table. The second was a boolean, which indicated whether it should be an local authentication provider, or an external provider (e.g., OAuth). At least, that's what the documentation says.The function would find and/or construct the correct type of provider, and return it. They all shared an interface, so this all should work just fine.But Paulette was left trying to understand the reasoning that lead to this line:

Gary inherited some C code. This C code is correct, and does what it is supposed to, which is itself a pretty straightforward problem: create an array of values from 0-N, arranged in a random order.Now, there are a lot of possible ways to do this, most of which involve swapping cells in the array around. It's quick, efficient, and easy to understand. Which means Gary's co-worker needed to find a better solution.

Geoinformatics ends up needing to deal with a pretty thorny problem: projecting a sphere onto a 2D coordinate system. There is no single correct way to do this, and depending on many factors, you may need to choose different projections- for maps covering small regions, the curvature of the Earth might have only a minor effect; the curvature is different depending on your latitude; depending on your needs, you might need different projections that prioritize retaining (or discarding) certain relationships between map coordinates.Given how hard this problem is, people have put a lot of time and effort into solving it with some standards. In this case, the standard is EPSG codes, a registry of reference systems, different values for the shape of the Earth, and different coordinate systems, all granted a unique identifier in the range 1024–32767.Each possible coordinate system has a different range of possible coordinates, and the coordinates mean wildly different things, so it's important to make sure that any coordinate you're passing around has its EPSG code attached to it. If you don't, the coordinate value is basically meaningless.Well, it's basically meaningless unless you're Samantha's co-worker, who came up with a "clever" solution for figuring out the ESPG code for a coordinate:

Jobhunter Quentin G. is finding the current labor market to be very challenging. Says he: "The job sounds cool, but that would be quite a salary cut."

Robert H is taking the first steps required to make existing code supportable: writing unit tests. The code in question isn't that old, it was just developed by someone who didn't care about mundane tasks, like testing.They also didn't care about things like paying attention to web standards, and thus were using the same copy/pasted utility functions they'd been using for a decade.The application in question was a web application with a large amount of client side code. The navigation system would construct a URL with a query string, then programatically alter the window.location.href property, triggering a page load.Now, since circa 2016, the "correct" way to manipulate search parameters in every browser that wasn't Internet Explorer is through the URLSearchParams object, which gives you handy-dandy get and set methods, along with some iterators.Some organizations might have been (or might still be- the horror!) supporting IE. But that doesn't really apply to Robert's case. But even if one were supporting a legacy browser, this pile of string mangling probably isn't the right way to do it:

It's rare to find truly self-documenting code. Adam, however, while hunting down a bug, found some.Adam was trying to understand exactly where some functionality was coming from in a Java program. The code base had some very long inheritance trees, which was an absolute nightmare for maintenance. The mix of overridden methods and mysterious interfaces and dependencies from the lowest levels of the hierarchy all the way back to the top created some of the most spaghettied spaghetti code you could imagine.While investigating, Adam found this wonderful piece of self-documenting code, sitting right at the top:

We’ve seen constants in the form of static final int ONE = 1 before. At this point, it’s barely worth discussing, it’s become so common. But Susan has found us yet another unique twist on the subject.It started when a contractor wrote Java code that looked like this:

Sole Purpose of Visit's team had a simple enough problem: they needed to generate unique labels for widgets on the screen. These widgets just need those unique IDs for internal purposes, so a simple incrementing counter would have been sufficient.That isn't the direction they went in.

In English we have common greetings and farewells thatmark salubrious moments in time, such as "Good Morning","Good Evening", "Good Afternoon", even "Happy New Year"or "Happy Birthday". The same is true for every tonguewith which I am even slightly familiar, to the point Iwill wager that it is common to every human language onthe planet. And yet, despite the invention of "le weekend"at least a century ago (variously attributed tolabour unionists, Henry Ford, or a nomadic monotheist),even the French have not yet penned a pithy phrase to herald the end of our conventional working week.

Francisco's co-worker needed to populate a dropdown with three items: "--All--", "Accepted", and "Pending". Unfortunately for this co-worker, a basic understanding of "array literals" or "lists" or, well, any collection type was slightly beyond their grasp. Instead, they chose to do what many a developer who doesn't understand the date/time functions of their languages does: ask the database for help:

Today's submitter works for a company that has a history of outsourcing pretty much all development, and to the lowest bidder, at that. This resulted in some terrible code, complete with 30,000 line classes, so the company decided to bring development back in house and clean up the code.After three years of hard work, the in-house team was proud to announce their new, more maintainable, version of the code. Unfortunately, they didn't have the best sense of what maintainable looked like, so their Java code had methods with signatures like this:

Today's story isn't really a WTF. No, Phil R was mentoring a new developer, and as such, Phil was sending some simple, easily scoped Python tasks over to that developer. After a few really low hanging fruit, Phil gave the Newbie a trickier one. The contact_type field was currently a string. That was a mistake, and it needed to be changed to a number. The change would involve a whole bunch of find-and-replace, but mostly it was just changing strings like '07' into 7.Newbie trotted off, and found this code block:

April Fool's Day happened over the weekend, which means no April Fool's Day post. I mean, I could have, but instead, I thought it would be fun to look into something that, once upon a time, wasn't a WTF, but honestly, always should have been.Our story starts with Jake, a relatively modern web developer, who was helping another developer, Jane, build a site-scraper for a local government's site. See, the government site couldn't be bothered with anything like RSS, so if you wanted a list of upcoming events, notifications, or other information, your only option was to load the page manually, or whip up a site-scraper that automated extracting that information.The problem was, Jane was finding some absolute nonsense in the HTML of the page, and it was incredibly difficult to parse out the information they were looking for. "What? How hard could this possibly be?" Jake wondered. He opened the site, viewed source, and was greeted with this:

Without much ado, five minidoozies follow.If it isn't one thing it's another, for our regular Argle Bargle."I looked outside. Everything was soggy and I could hearclaps of thunder. How long will it last? Click on weatherand... um... Fire Weather? I can think of only one wayI'm getting a fire going in my backyard right now and itinvolves a flamethrower." It's better than tornadoes!

Structured exception handling is an excellent way to handle errors, but wouldn't it be nice if you could execute a different branch of code depending on what specific error just happened? It's a pity that there's just no possible way to filter exceptions using the good old fashioned try and catch. Fortunately, Mateusz has a co-worker who invented that wheel for us.

Relational databases were at one time an absolute standard that nearly any developer could be expected to be familiar with. These days, it's still valuable knowledge, but it's less surprising when someone doesn't know more than the basics- there are so many other ways one might persist data, each with their own tradeoffs. But if someone is developer for a contracting firm specializing in data driven applications, you would expect them to have a little more grounding in RDBMSes than the average developer. Well, you would expect that if you thought the contracting firm was actually selling a valuable service, instead of trying to bilk their customers and their contractors and hope nobody notices.The important things about RDBMSes is that each table represents a relation- a set of fields that are all conceptually related, like "Employee" (with an employee ID, a name, a hire date, etc.) or "SalesListing" (with a product description, a price, etc.), and then those tables can have relationships to other tables- foreign keys that guarantee that if "SalesListing" has a "SalesRep" field on it, that "SalesRep" has a matching entry in the "Employee" table.Roman received some SQL code from one such contracting firm that perhaps highlights where these sorts of things might go wrong:

While the world has switched to RESTful APIs, the magical power of SOAP-based web-services was that they made code generation easy. Well, easy-ish. Well, easy when it worked right, and then hard the rest of the time. But if it worked, if the WSDL was up to date and sane, you'd get a nice client-side API to invoke methods on the remote server.Andrew inherited one such client-side C# API. It looked something like this:

Dates and times are way more complicated than we usually think they are, especially when we're talking about historical dates and times. The solution, of course, is to always use someone else's work, whether it's a library or your language's built-ins, never implement date handling yourself.For a long time, though, Java's date handling left something to be desired. Which is why Sven found this history lesson in his company's code base:

Many years ago, at the height of the Industrial Revolution, theUnited States was criscrossed by a riot of regional railroads.Gradually, these were acquired or merged until nowthere are only about a half-dozen majornational railroads. In a similar fashion,at the birth of the public Internet, there musthave been thousands of community Internetservice providers. It seemed like every town had its own entrepeneurial enterprise, with some racks of modemsin an office somewhere. Those quickly got snapped upor forced into bankruptcy, as legacy cabletelecoms companies leveraged their existing monopolies into a new line of business. Which brings us to this week's Error'd. Enjoy(?) it.First up,Adrian McCarthy grumbles "Getting help can be difficult when your regional monopolyinternet service provider cannot assemble a functionalweb site. Note that the understandably required Descriptionfield in this online support contact form is disabled."

Ah, the joys of stringly typed code. Everything can be turned into a string, so why not treat everything as a string? It certainly worked for Sebastian's co-worker, who also took it to another level:

We like using constants instead of magic numbers. Today, we see an unusual misuse of them. It's unusual because, while it's a set of bad choices, it's not quite a `#define ONE 1` level of silliness.First, a little background. Benjamin inherited a building automation system. This building automation system was implemented in Microsoft's Visual C++, version 6.0, way back in the 90s. As of the late 2010s, not only was it still in use, it was still pinned to the same compiler version. So not exactly the most modern of applications, but it accomplished the business goals, albeit with a lot of bugs, errors, and mysterious glitches.Here is how the application checked how long an operation took:

Pretty much all object oriented languages have some concept of "destruction": objects need to release any resources they acquired at construction. In a lot of cases, we don't need to customize this terribly much, but when we do, it's vitally important to do it correctly.Nancy's co-worker perhaps didn't understand the "correctly" part. So this was the standard pattern of C++ destructor that they wrote:

Managing the requirements for an application is a huge challenge. The hardest part of the challenge is that, very frequently, the user's don't know what they really want or need. Prying it out of them, and giving them an application that actually solves the real problem they have, is an art.The worst situation is when the users are absolutely certain that they do know what they want. This was the situation that Irini found herself in.The project started, as many such projects do, in the wake of a disaster. One of the company's many Capital Improvement Projects (CIP) slipped through the cracks during budgeting. It ran six months past schedule, but managed to close out with a few hundred grand still unspent in its budget. When someone tried to reallocate that money, the management team in charge of managing CIPs found out, they went full code-red, trying to do two things at the same time: understand why that project got lost in tracking, and also why when they tried to reallocate the money, it kept getting reset in their Enterprise Resource Planning (ERP) system.Eventually, that lead them to Sofia, the VP of Finance, and managed them all through a spreadsheet she had created by herself. The ERP kept getting reset because she manually updated it based on the contents of the spreadsheet. The project got lost because she manually color-coded the projects in her spreadsheet, and one day accidentally hid the row, instead of making it yellow.No one liked that there was a manual process. No one liked that only one person ever touched this system. Management wanted a robust, backed-up IT system, and wanted to open the management of this process to more of the finance team, so Sofia wasn't the only failure point.The solution was clear: gather requirements from Sofia and either purchase a product or develop something in house to replace the spreadsheet. Very quickly, it was decided that "develop in house" was the only way to customize the tool to what Sofia's process already looked like, and "standardizing the process" was not an option.Irini was on the IT team that was chosen to build this product. A business analyst tried to sit down with Sofia to suss out her actual requirements, but hit a brick wall. The spreadsheet already did everything she wanted. The spreadsheet was the requirements. She gave the analyst a copy and sent him on his way to get something built.As mentioned, Sofia manually color-coded the rows in the sheet to help with project tracking. Fortunately for the development team, her spreadsheet included a key, describing what the colors meant. Unfortunately, it was this "technicolor yawn", as Irini puts it:Now, as "re-implement this spreadsheet as an application" goes, this isn't terrible. It's an ugly, complicated set of rules, but at least it's documented. But what we have here is a case of one person's idiosyncratic style of organization determining the features for all users of the application.This is what the users said they wanted. This was what the dev team implemented. Everyone on the dev team suggested that maybe they needed a better way of letting users filter, sort, and prioritize their capital projects, possibly even allowing each user to manage custom filters, but no- the spreadsheet was the requirements.When the app launched, the Finance team was excited to have more control over their capital projects. Then they started to use the application, and quickly got confused. It was built, not to solve the problem of managing projects, but to fit Sofia's workflow, and her workflow alone. It was impenetrable and opaque to everyone else. After a few months of endless tickets as users got lost in the confusing interface, most of them gave up.Sofia stuck with it longer, but she hated the application. As it turned out, automatic color coding was a big anti-feature for her, because the rules she had in the sheet were just guidelines, and she wanted to be able to apply any color to any project based on information that existed only in her head.The application is still technically running, but nobody in Finance is using it. They've reverted back to "Sofia has a spreadsheet for it." [Advertisement] Otter - Provision your servers automatically without ever needing to log-in to a command prompt. Get started today!

We got quite a few irregular submissions this week from regularcontributors. Which is to say routine contributors. We're not qualified to make judgements about whether or not anyone is whatwhat most folks would call normal.First up,Isaac D. is struggling with localization,kvetching"Apparently this number format is ALIVE and WELL in partsof India and Afghanistan, but us poor Australians on desktopbrowsers also seem to be visually assaulted with it. Iwonder if the Zuck will pay me $1,00,000 for reportingit or do real country borders mean nada in the Metaverse? ;)"This would ordinarily be controlled by some operatingsystem or browser configuration, would it not?

James's management had more work than they had staffing for, so they did what any company would do in that situation: expand their staff. No, of course not, I'm kidding. They bundled up a pile of work and shipped it off to the contractor who gave them the lowest bid, provided absolutely no oversight or code-quality standards in the contract, and hoped for the best.What they got back was a gigantic pile of code that compiled. That is the only positive thing one can say about the code, because it certainly didn't work. Within a few weeks of starting reviewing the gigantic pile of garbage the contractors turned in, the dev team reached the decision that it would be quicker to rewrite from scratch than it was to try and pick apart the trashpile and reshaped the refuse into something approaching their actual requirements.James sends us just one small VB .Net property definition which summarizes the kinds of problems they were dealing with: