Is it a good sign when someone associates your code with a type of pasta?
Does it take you longer than expected to finish a task? Are you struggling a bit too hard to meet the project’s deadlines? Consider taking a look at your code’s structure to check if it has a logical structure. If it’s not easily readable and understandable, your code might be an anti-pattern. According to DevIQ.com,
“Anti-patterns are simply design patterns that in many cases introduce more problems than they solve. Sometimes these are coding patterns, while others describe problems within teams or organisations.”
The Pasta Theory is a popular analogy used to describe several types of anti-patterns as popular pasta dishes. In the culinary world, there is no such thing as “bad types of pasta”. In the programming world though, you should keep your code away from any kind of pasta.
Great code isn’t just about making the program work. Successful software development is about making sure your program will continue working. While creating code that’s maintainable is one of the hardest parts of a programmer’s job, it’s also one of the most important objectives one should focus on. So, if your code is not maintainable, you can associate it with a type of pasta. The most popular dishes in your menu can be: spaghetti, lasagna, and ravioli.
Spaghetti code is unstructured and complicated to maintain. As each code line might be referencing almost any variable located anywhere in your program, sustaining it can feel like mission impossible. The risk of introducing bugs elsewhere is alarmingly high. A perfect example of spaghetti code is when a program has lots of GOTO statements instead of structured programming constructs. But, thanks to this Reddit thread, we have a solution to spaghetti code: usage of an aggressive and proactive refactoring effort focused on keeping programs small, effective, clean in source code, and coherent should help.
I wouldn’t mind some lasagna right now, but your program would mind being developed with a lasagna structure. This one is defined by having way too many layers and by being a little bit too abstract. Instead of a small range of larger classes, your program has a lot of small, unnecessary classes. How does this happen? As a developer, you might have the tendency to write it as if every subcomponent necessitates its own object. If your classes are very small, it’s time to take a step back and check if you’re over-abstracting your code. Even though your structure is understandable and it has a clear flow, it’s not a structure that easily welcomes changes. To modify something you’d have to go through all the other layers to assure no harm has been done to your program somewhere else in the code. An example here would be object-oriented code with a lot of small classes.
If your code is ravioli, then you might be close to being on the right path. As mentioned here, “ravioli code is a design pattern that has the right idea, but it can get out of hand quickly.”. The resemblance to ravioli comes from how your code has small, self-contained classes, just like individual pieces of ravioli. And, as each component is isolated from external dependencies, the process of code testing and validating gets easier. However, this one has its downsides as well, as it’s not a pattern that easily welcomes changes either. The risk of making your code too abstract is here too, just like in the lasagna case above. In this case, over-abstracting can determine the individualised components to significantly increase your codebase’s call stack. Ultimately, your code will be hard to maintain in this situation as well.
Don’t mess the culinary world with the programming world. Developing code that’s maintainable, reusable and durable is easier said than done, but you’ll thank yourself later for prioritising it. It would be great to have a recipe for developing durable code, but it varies from language to language, framework to framework, or team to team. What’s important to keep in mind is that today’s best coding practices can quickly become tomorrow’s anti-patterns. As long as you keep an eye on maintaining your code fresh, easily understandable, readable, and well documented, you’re on the right path.
There are a few more dishes available on the menu, but the ones mentioned above are among the most popular. However, your code can also be macaroni (code that uses a mixture of programming languages in a single document), pizza (code with a flat architecture), baklava (codebase with too many architectural or abstracted layers, it’s similar to lasagna), and so on. To check out more examples of anti-patterns (not necessarily food related) and ways to avoid them, check out this article, or this article, or this article. Oh, and Happy Late International Pasta Day (25th of October)!
Article written by: Ruxandra Mazilu