Scaling the API design review process at Google
Google’s API Governance process makes sure that the design and development of its APIs meets the company’s standards.
“Heap, Heap, Array!”
Prompt patterns for LLMs that help you design better software
Large language models (LLMs) may not be replacing developers anytime soon, but can still be of use in the design process.
Recovering software architectures via chain-of-thought prompting
Large language models can be used to deduce to what extent your system’s implementation still adheres to a reference architecture.
Comparing algorithms for extracting content from web pages
This study pits 14 open-source main content extractors against each other and arrives at a somewhat surprising conclusion.
The challenges of end-to-end testing and how to face them
End-to-end tests can help you discover problems in web applications, but sadly are not free of problems themselves.
Five things in Python that I only learned this year
Many people learn Python as their first or second programming language, but only few people bother to master it.
PHP developers hate him! Find out these weird tricks they don’t want you to know!
Three “fun” ways to throw off fellow PHP developers (and the “fractal of bad design” article isn’t one of them).
How software developers deal with flaky tests
Flaky tests can cause CI builds to fail unexpectedly, and should be fixed as quickly as possible. This study shows why.
Improving search results using query expansion
Make your custom-built search engine return more relevant results by automatically adding similar or related words to search queries.
GitHub Actions is eating the world
Since its introduction a few years ago, GitHub Actions has become the dominant CI service. How did this affect competing CI services?
There is a time and place for log statements, but when and where?
Logging statements can be very valuable for various reasons, but aren’t entirely free of cost. What’s the best way to use them?
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.
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 (part 2 of probably more than 2)
Yet another blog post where I create an unmaintainable mess using our favourite yet very inadequate programming language, SQL.
Let’s build a simple journey planner using SQL (part 1 of definitely more than 1)
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.