New PHP 8 language features that you may have missed
PHP has gained a lot of new language features over the years. Some of them are frankly a bit insane – but in a good way.
“Heap, Heap, Array!”
Enhancing the pull request experience with meta-bots
Pull request bots can provide both maintainers and contributors with a lot of useful information, but sometimes less is more.
Let’s build a simple journey planner using SQL (yes, you read that right)
When all you have is a relational database, everything looks like a table. And you know what? It works! Sort of.
Proactively detect and fix flaky tests in your test suite
Proactive detection of NIO tests makes it possible to fix flaky tests before they ever cause any problems.
How to write good commit messages
In today’s “Things That People Don’t Want To Bother With” blog we’re having a look at commit messages and how to write them.
Handling model inheritance in Laravel’s Eloquent ORM without third-party libraries (is a bad idea)
It’s technically possible to make Eloquent models inherit from each other, but I probably wouldn’t recommend it.
Bad practices in continuous integration pipelines and processes
This catalogue of 79 bad smells can help you make your continuous integration processes less shitty.
How to write good code comments
In this latest instalment of “Things That People Don’t Want To Bother With” I discuss best practices for writing comments in source code.
How many unit tests should you write?
How many unit tests are enough? As always the answer is “It depends”, but fortunately there is a handy rule of thumb that you can use!
The Chicago and London schools of TDD
Tests can be written Chicago-style or London-style. Neither is strictly better than the other; which style should you use?
First make the tests easy, then make the easy tests
The best time to make your software testable was at the start of the project. The second best time is now.
Structure your tests using the Arrange-Act-Assert pattern
Arrange-Act-Assert is a standardised approach to writing tests that makes them easier to read and helps you avoid some bad practices.
How many spaces should you indent your code?
None, because tabs are better than spaces! Joking aside, it appears that the exact number doesn’t matter that much.
Everything that management needs to know about technical debt
Developers often complain about technical debt, but how much does it really hurt the business? According to this study it’s *a lot*.
How developers perceive and deal with architecture erosion
Let’s talk about architecture erosion, its causes and consequences, and how developers can identify and control it.
Why snake_case is better than camelCase
There aren’t many reasons why you should choose snake_case over camelCase, but the ones that are there are pretty convincing.
Why camelCase is better than snake_case
Does it matter whether you use camelCase or snake_case for identifiers? Yes it does! Probably. Maybe.
A checklist for controlled program comprehension experiments
If you want to study the effect of something on the understability of code, you need a controlled experiment. What are things to do or avoid?
What is the best programming language for beginners?
This study attempts to provide a more nuanced answer than “JavaScript”, from an educator’s perspective.
Storing trees in a database table
Relational databases are very good at storing tabular data, but what if you need to store arbitrarily-sized trees?
How to deal with Dutch compound words when processing text
The Dutch have a lot of long words that aren’t in dictionaries. But that doesn’t necessarily mean they’re hard to read for Dutch people.
Is there a time and place for single-letter variable names?
We are often told that variable names should be meaningful and avoid abbreviations, yet some variables are simply named “k”. What gives?
Casting doubt on the ability of tools to measure technical debt
Numbers produced by technical debt tools tell a tale, but it’s largely fictional.
What do regular expression bugs look like?
This study gives us a better understanding of the practical problems faced by developers when using regular expressions.