I have stubborn code. There is this one code file that I need to change for almost every new feature, and I always run into… Read More »Turning Water into Wine: Refactoring Rotten Code (Full Day Workshop)
This presentation reviews some of the most common and dangerous code smells and anti-patterns supported by some debate about why they should be avoided. There… Read More »Sniffing Out Success: Identifying Smells and Anti-Patterns in Your Code
I had pretty much assumed that nearly all software developers would know what I mean when I use the words anti-pattern and code smell. Over the last couple of months, I have come to the conclusion that this is not strictly true.
When asking this question, I have received a number of different responses. Everyone seems to have a basic understanding, but most don’t have any clearer idea than “it’s bad code.”
To understand what an anti-pattern is, you must first know what a pattern is.
Read More »Anti-Pattern and Code Smell Defined
Object pools are a common pattern in development. The canonical example is probably a database connection pool.
If objects returning to the pool are not validated, the pool can gradually fill with garbage objects, turning it into a cesspool of unusable objects.
The two easiest ways to identify if your object pool may become a cesspool:
Read More »Object Cesspool Anti-Pattern
As an anti-pattern, input kludge describes a poor user interface that either rejects or incorrectly handles valid input.
The most obvious code smell that may point to this pattern is ad-hoc input validation routines.
Look for:
$('form').on('submit', function(event) { if (!(/^.*@.*\.(com|edu|net|org)$/g.exec($('#email').val()))) { alert('You must enter a valid email address.'); return false; } })
If you know what a pattern is, then you probably already know about anti-patterns, even if you didn’t know it! In a nutshell, a design pattern is an observed good method to solve a re-occurring problem. You have probably observed patterns in your own development.
For instance, maybe you have an object that needs to be accessed by multiple threads, but the integrity of the application requires that there be no more than one instance. In the countless times that this problem has been solved in the past, most “good” solutions have taken a similar form… what we now call the Singleton pattern.