How To Avoid Dumb Code Mistakes Part III

Episode #3: Timeless Programming Paradigms

Published: August 09, 2020

Tags:

by Jack Kinsella

@semicolonandson

Continuing on from part III, this episode focuses on reducing silly mistakes when programming. Do you truth-table logical possibilities to ensure you don't miss a critical branch in your logic? When you discover a bug, do you search the rest of your code for parallels that are caused by similar mechanisms or the same misunderstanding? And, lastly, are you running all those tests and linters you wrote on a regular basis?

People LOVE ❤️ Semicolon&Sons

10,000's of programmers have picked up new tricks and/or made progress growing their software businesses.

These screencasts are great - I love the intentional focus on marketing as well as technical excellence.

Cliff Weitzman (Forbes 30 Under 30)

This content is absolute gold.

Ben P

Finally, a real enginner showcases a real world project.

Hải Vũ

That's not all either. Keep reading praise for Semicolon&Sons.

Get Episode Alerts and Freebies ⭐️

We publish a video once every week, on Sundays. Every 2nd video is completely free to watch.

If you'd like, we can remind you via email when a new episode is released. We'll also keep you up to date about the top-secret game we're developing for learning programming.

Screencast.txt

transcribed by Rugo Obi

In software, mistakes matter.

This is especially true for indie hackers because the buck stops at them... they have to take ultimate responsibility for any problems in their code.

My approach for dealing with this is to create a checklist of common dumb errors, and this is the third part of that series.

Tip 8; Enumerate Logical Possibilities (e.g. With A Truth Table)

Tip 8, have you enumerated all the logical possibilities?

The best way to do this is with a truth table. You’re looking at one right here from Wikipedia.

It's a table that summarizes how we can combine the values of two or more propositions using some sort of logical operator.

Here we have proposition 'P', and proposition 'Q'. And here’s the logical conjunction of them: the 'AND' operator. True & true is true, true & false is false, etc. etc.

Using a truth table acts as a sort of logical checksum that you've considered all the possibilities. If you failed to consider one of these, you probably have some sort of bug in your system.

Say you're programming a job board, it has a filter for the degrees of commitment. You have a checkbox for part_time, and a checkbox for full_time.

The non-rigorous way to program this is to just dive right in. This is what I initially did back when I first built a job board like this.

Here's the code I had that was buggy.

The way this works is that it looks if the part_time checkboxes is filled and if it is, it filters for all the part_time ones.

Otherwise, if the checkbox for full_time is checked, it filters for all the full_time ones.

At first glance, that seems kind of plausible, but, in fact, it's buggy in a pretty serious way.

The problem is that it only considers half of the logical possibilities.

In this file, I've created a truth table of all the logical possibilities for combining those two booleans. Here are the possibilities.

In the first column is the full_time checkbox, and in the second column is the part_time checkbox.

So first is the possibility where both are checked. This is something I did not consider in my previous code.

Then there's the two possibilities where one is checked, either the full_time or the part_time. The star * here indicates that I had considered it.

And finally, here's the case where neither are checked. I also did not consider that option.

Let's open up my original bad code to see how it fares when we consider it under the lens of the truth table.

So let's imagine case one where both checkboxes are checked.

In this case, my code will hit this line. If the part_time boolean is true, the part_time checkbox is ticked, that evaluates to true. Therefore the $query is where part_time is true. This bit, being in an else statement, is never executed.

The result of this is that records where the full_time attribute is ticked, but not the part_time one, will not be returned when both are ticked. I.e full_time jobs will not be returned from this query.

This is obviously a severe bug.

In the new and improved code over here on the right, I have addressed this particular logical case by having a line for when full_time and part_time are both ticked.

In that case, I add no filters whatsoever. The idea being that no filters corresponds to all records.

As for the fourth logical case here, by random chance that happens to work with my existing code here, because when there are no filters I should return all records. And that's the default not shown in this particular function. So that works.

However, in my more rigorous code here, I've explicitly documented that case and made it clear to all of the programmers what's happening.

One last tip on truth tabling:

When dealing with truthiness condition predicates, you’ll need to consider two to the power of n (2^n) possibilities to be complete. I.e. here we have two predicates, two to the power of two is four, so there are four different conditions to consider. Here we have three inputs, three predicates, and there are two to the power of three possibilities to consider. And with four, we get two to the power four or 16 possibilities.

Tip 9: When You Find A Bug, Proactively Look For Parallel Issues.

When you fix a bug, have you searched through your code for parallel instances of that same bug?

Many of my bugs over the years have been due to a misunderstanding of some programming language concept or some API.

Therefore, when I find one mistake in my code, it's darn likely there are others caused by that same misunderstanding.

Therefore, I find it’s worth greping through my codebase or even through multiple code bases for any signs of similar bugs after discovering the initial bug.

I can give you an example of this.

So here's my product page in Oxbridge Notes, and this is the product description here. You can see it has multiple paragraphs at the moment.

Anyway, one of the authors in my system sent me a complaint that whenever he created these descriptions in the kind of dashboard for authors, his new lines between paragraphs got stripped out by my system. And therefore, it was just one big, ugly, blob of text.

I traced this bug, back to this line of code here (normalized_attributes) being active on the description field. It should not have been active on the description field.

What was happening behind the scenes here is that on this description field here, squish was being called automatically as one of the ways to normalize a field. Let me show you what that actually means in context.

So, here I have some code to set a description with some new lines. And if I print that subject.description, you can see that the new lines are preserved.

However, if I print subject.description.squish, the new lines are no longer there. In fact, let's show you what the description field looks like normally, and then with the squish... You can see they're gone.

Removing the description field from the normalized_attributes macro here fixed the proximate problem, but I was lucky enough to grep through the entire code base and check out all other instances where I called normalize_attributes, in order to check whether or not I had other instances of this bug.

And sure enough, for example, here in the tutor file. I was also doing it to the tutor :description which was a very similar system. Therefore I deleted that version too.

In checking for parallels like I did, I got two or three times as much bang out of my debugging time.

Tip 10: Run Your Linters And Tests Consistently

Tip 10, those linters and tests that you wrote, are you actually running them before every one of your deploys?

Tests slow you down. Sometimes they can take 5 minutes, 10 minutes, 20 minutes... God knows how long, in order to fully execute.

Time and time again, I see undisciplined programmers, including me when I'm misbehaving, trying to outrun these constraints, due to hubris and usually with disastrous consequences.

This is cowboy-coding.

Ultimately, you need to convince yourself that waiting those extra 10 minutes or so to deploy is worth it.

Many people, including myself, use little hacks to get around our impatient tendencies.

For example, on the Semicolon&Sons codebase, I'm only able to deploy after running my continuous integration tests in Circleci.

Here we can see that once those tests pass, I’ll get a job to deploy on Heroku and migrate and all that kind of stuff.

Of course, it's always possible for me to deploy without this, I just have to rely on my own discipline not to find a way to deploy outside of the usual rules.

Another common technique to ensure that unit tests, at least fast tests and linters always get run before every single push to GitHub; git-hook. For example, here's a pre-push git hook I used in one of my codebases.

This code, essentially runs a whole lot of linters command like rspec, like brakeman, that looks for, I think security holes, Rubocop is a Ruby linter, ESLint is a JavaScript linter, Stylelint is a CSS linter, Shellcheck is a shell linter, and so on and so forth. Here's a scan for DEBUGGER_STATEMENTS that accidentally make it into production - you don’t want that. And then it only pushes if all of these checks pass.

Much to my dismay, I found that sometimes in GitHub, code that failed these tests would appear there. This was because a colleague managed to skip these git hooks.

That's because these git hooks usually get run when you do a standard git push, but there is an option here, --no-verify, that allows you to push without it, and my colleague used to use that, and that was extremely frustrating. It pissed me off. In my opinion, that is total abandon and arrogance to think that you're better than your tests, and it made me lose faith in their professional abilities.

Before concluding, I'd like to point out how these tips build on one another and overlap. For example, if you proofread all your commits, then you'll probably notice that the changes you made were not in the right file. Or if you executed every line of code you changed, you probably also noticed the bug as well.

However, because we are imperfect humans, we do these overlapping checks in pursuit of some rigor, that's really the best we can hope for.

Thanks for watching.