Latest Posts - Page 51 of 192

April 12, 2022April 4, 2022 Architecture Patterns and Anti-Patterns

Technical Debt – Yes, That Is A Pattern

The idea of technical debt is a hot topic among software development groups. In particular, this concept shows up in agile efforts. While it is more a concept than a pattern, we can use this as a pattern for our design and development work. In fact, it lines up well with the Pareto principle and pushing details off until after delivery. The Technical Debt Pattern Defined I like to think of technical debt architecture as boxes and connections that are dotted lines. We sometimes see a whole section of functionality surrounded by a dotted line fence. These are referred to as future features or possibly optional. These items are, in fact, technical debt in the design. We are assuming they... Read more

April 7, 2022March 24, 2022 Architecture Patterns and Anti-Patterns

The Cancer Pattern – One Place The C Word is Ok.

The Cancer pattern has a word we do not have a favorable view of. However, this pattern is becoming needed in more and more environments. This pattern is one for conversions and migrations. We do not always have a clean slate for our architecture. Thus, we need designs to handle the modification of an existing architecture. The Cancer Pattern Defined The way Cancer evolves is that it replaces cells with something new while leaving things functional. This approach is how we often want to replace a system in place. We cannot shut things down and might not be able to do a swap. The cancer pattern is a sort of “hot swap” of a system with a new solution. We... Read more

April 5, 2022March 24, 2022 Architecture Patterns and Anti-Patterns

Keep It Simple – A Pattern To Avoid Complexity

We return to pick up a couple of new patterns. In this episode, we look at the keep it simple pattern and how to apply it to architecture. It is a pattern that we often overlook. However, it is an essential piece of many successful solutions. It is the heart of our desire to break complex things down into small pieces we can tackle. The Keep It Simple Pattern Defined We run into this pattern, or mentions of it, in many areas of life. Software architecture is no exception. When we face a decision to build a complex solution or a simpler one, we want to choose simplicity. Yes, complex solutions can be fun to tackle and impressive. However, they... Read more

March 31, 2022March 19, 2022 Architecture Patterns and Anti-Patterns

Misdirection Anti-Pattern : Solving The Wrong Problem

We looked at an incorrect focus based on faulty data analysis in our prior episode. This time we explore solving the wrong problem with the misdirection anti-pattern. While this situation can arise from the data bigotry anti-pattern, it is often a failure to grasp requirements fully. It is a problem that comes from improper focus and lack of communication. Those are two prevalent weaknesses in a project that lead to challenges and even failure. The Misdirection Anti-Pattern Defined This anti-pattern is simply defined. We are not solving the correct problem. Yes, there is a problem described, and it might even be correctly addressed. However, it is a red herring of sorts and not what we need to solve to make... Read more

March 29, 2022March 19, 2022 Architecture Patterns and Anti-Patterns

Statistical Bigotry – Placing An Incorrect Emphasis

This podcast season is a great excuse to highlight new anti-patterns. We look at a new one we call statistical bigotry in this episode. That is an excellent emotional word and a common challenge across many areas of problem-solving and debate. This anti-pattern appears when we give too much weight to our data and improperly use statistics. Statistical Bigotry Defined We use data and facts to support our decisions regularly. However, we can not blindly use data in this way. We need to ensure the basis for our decision is based on overall reality instead of a small subset. When we improperly use a small subset to assume the whole, we are committing statistical bigotry. The issue may arise from... Read more

March 24, 2022March 11, 2022 Architecture Patterns and Anti-Patterns

Stovepipe Enterprise – The Patchwork Anti-Pattern

We have highlighted many areas of quality software development. However, the stovepipe enterprise is a maintenance anti-pattern. This situation occurs when we build a system that has a high maintenance cost. Even worse, maintenance often requires to be done quickly and more as a patch than a build. Therefore, we produce a house of cards that becomes more fragile as time goes by. Stovepipe Enterprise Defined Stovepipes are historically a form of a kludge. Wood-burning stoves needed a way to get rid of the exhaust, and it goes through the pipe. However, the material often wears down a stovepipe quickly, and it is patched with whatever materials are available rather than replaced. We see this in software solutions when we... Read more