What Devs Mean When They Say Software Is “Complex”

In the world of custom software development, you often hear developers describe a piece of software as “complex”. But what exactly does that mean? Is it just a buzzword, or is there any substance behind this term? 

Software development is a multifaceted process that often involves discussions about the complexity of the systems being built. In this article, we will dive into:

Moreover, we will discuss whether complexity is inherently bad. 

Why Does Complexity Matter in Software Development?

Complexity in software is closely tied to risk. The more complex a software system, the greater the potential for various types of risk:
  • Bug Risk: Complex code may hide bugs that are difficult to detect during software testing and development, increasing the risk of post-release issues.
  • Maintenance Risk: A complex codebase is harder to maintain, leading to higher costs and more frequent updates.
  • Performance Risk: Complex software may not perform optimally, causing slow response times and resource inefficiencies.
  • Scalability Risk: Scaling a complex system can be challenging, as its intricacies may lead to unforeseen issues when new components are added.
  • Security Risk: Complex code may have vulnerabilities that can be exploited by malicious actors.
  • Unknowns Risk: A system could sometimes be complex due to the team not having sufficient experience with building this type of system.

For both product and engineering people, it is crucial to have an understanding of complexity so that we can manage scope, budget, and time expectations.

Unpacking Complexity

There are a variety of reasons why the complexity of custom software can grow over time. One of the greatest challenges in developing software is to decide when to “stop”. 

When are we as developers satisfied with our implementation? How much time, effort, and budget do we want to spend on making this software better? How strict are the given requirements for the behaviour of this functionality?

With any given software requirements, numerous ways exist to solve the users’ and the business’ problems. Over time, the intricacy and complexity can easily grow for the following reasons:

Complex Logic

Complex logic in software involves intricate decision-making processes. It might entail numerous conditional statements, loops, and branches. Complex logic can be challenging to follow and may result in bugs or unintended behaviour if not carefully managed.

Complex Implementation

Complex implementation often pertains to the way code is written and structured. It can include overly long or convoluted functions, a lack of code modularity, or a high degree of code duplication. This makes the codebase hard to maintain and extend. 

This is often seen in long-running, core functionalities of a software system, when new requirements are steadily introduced over a long period of time, and time-to-market for these new requirements is very important. In this instance, developers do not have time to rewrite or refactor the existing code to allow for the new requirements to be added easily.

Complex to Change

Complexity can also refer to how challenging it is to make changes to the software. A complex system may resist modifications or require extensive testing after even small changes, which can slow down the development process. 

Change complexity is an important factor to consider when new functionality needs to be added. When a piece of software has grown steadily over a long time, it can become difficult to change existing behaviour. Not only does it become difficult, but the risk associated with making these changes is greatly increased. 

Complexity Measured

Measuring software complexity is crucial to understanding the scope and impact of complexity within a project. Two main approaches are commonly used for this purpose:
Quantitative Measurement
Quantitative measures of complexity often include metrics such as cyclomatic complexity, cognitive complexity, lines of code, or code churn. Cyclomatic complexity, for instance, quantifies the number of decision points in a program, giving an indication of its logical complexity. Cognitive complexity measures how difficult a piece of code is to understand At Polymorph, we use Sonarcloud to assist us in managing complexity and technical debt to ensure we build software better.
Qualitative Measurement
Qualitative measurement, on the other hand, involves assessing complexity through code reviews and expert judgement. This approach focuses on the readability, maintainability, and overall structure of the codebase.  While it may not provide precise numbers, it offers a more nuanced understanding of complexity.

Avoiding Complexity

Developers strive to avoid unnecessary complexity and manage essential complexity. Here are some strategies to achieve this:
  • Simplicity in Design: Keep the software design simple, favouring straightforward and modular software architecture.
  • Clean Code Practices: Encourage clean coding standards, which include writing self-explanatory code and minimising code duplication.
  • Modularization: Break the software into manageable modules or components, making it easier to understand and maintain.
  • Documentation: Thorough documentation can make complex code more understandable for developers and stakeholders.
  • Code Reviews: Regular code reviews with peers can help identify and rectify complexity issues early.
  • Testing: Implement comprehensive testing strategies to catch issues related to complexity, including edge cases.
  • Refactoring: Regularly revisit and refactor complex parts of the codebase to simplify and improve them.
  • Choosing the Right Tools: Select tools and frameworks that align with the project’s needs and can help manage complexity effectively.

Is Software Complexity a Bad Thing?

While complexity is often associated with challenges and risks, it’s not inherently a bad thing. Complexity can be a byproduct of solving intricate problems or building highly functional software. In some cases, it’s a necessary aspect of delivering valuable solutions rapidly. However, excessive complexity can be detrimental. It can lead to development delays, higher costs, and decreased software quality. Therefore, the goal is not to eliminate complexity entirely but to manage and control it to strike a balance that supports the project’s objectives.

Control complexity, strive for simplicity

When software developers describe software as “complex,” they are highlighting the intricate nature of the system, involving complex logic, implementation, and resistance to change.  Measuring complexity quantitatively and qualitatively helps understand its extent and impact. Complexity is closely associated with risk, which can manifest in various ways, but it’s not inherently bad. The goal is to manage and control complexity to strike a balance that supports project objectives.  By following best practices, avoiding unnecessary complexity, and staying vigilant, developers can navigate the intricate world of software development with confidence.

Planning to build an app? 

Try our free software development calculator to maximise your ROI.

Request for Access to Information

The following forms are available to download with regards to request for access to information: