Clients sometimes ask us whether a software project is hard to build. In most cases, it’s not difficult — but it can be complex. Exactly how complexity affects software projects is one of the more difficult things to determine on a case-by-case basis, but it is essential to a client’s project success.
Renowned software engineering author Steve McConnell says that “software’s primary technical imperative is managing complexity.” In that sense, managing complexity is at the heart of every software project we undertake.
What Makes Software Complex:
Complexity Affects Timeline
While it’s not difficult for veteran developers to solve complex problems using software, it does take effort. As a result, the more complexity planned for a software system, the more time that effort will take.
We must spread that effort out over more calendar time in order to effectively complete this complex work. We make sure to schedule enough time so we can find and correct bugs, conduct hallway usability testing and ensure each functionality piece is working well so they can build effectively off each other.
Complexity Affects Budget
Because complex software takes more time, it costs more money to develop. Complexity also adds to budget because it adds risk to a project. At Worthwhile, we’re committed to delivering software on time and on budget. This means we must consider risk in all the estimates we create, to be responsible to our clients and to our business.
Here are two key complexity-related questions to ask before building software:
How do I assess the complexity of what I want to build?
It can be hard for non-developers to know what creates complexity when it comes to software. So it may help to understand how software programmers approach the building process. When building software, we try to (as Code Complete puts it) “define and constrain the unpredictable and approximate actions that happen among things in the real world, in order to make them fit inside a predictable and exact computer program.” So things that lead to less definition and/or fewer constraints create complexity. Even a simple, user-friendly interface can include complex development.
We’ve learned from experience that the following things can create this kind of complexity:
- Displaying different things in different ways to different audiences
- Giving users and/or administrators the ability to configure the software
- Replicating complex decision trees in software (because that makes the software as complex as the original business process)
- Interrelated features where changes in one part of the system cause changes in another part
- Integration with external data sources or software
What complex features can wait until later?
The good news is that a software system doesn’t have to have every possible feature at launch. It’s important to understand what the essential parts of your system are, and what features are not essential but instead enhance user experience and make the software stand out in the marketplace.
Once these decisions are made, we start building the essential parts of the system. Then we begin testing—and even invite our clients to get potential users to test. This does two things: it confirms that the essential parts of the system are working as they should, and they identify what features need to be added to enhance the user experience so customers find the product worth buying.
This process (called evolutionary prototyping) allows us to work with clients to determine what features need to be added, and in what priority. We use this process to ensure that the build focuses on vital features so the client can launch a product with the needed breadth and depth to be viable in the marketplace. Plus, the client can then make wise investment decisions about adding features in future versions.
Software complexity isn’t something to be avoided. In many cases, it’s what makes a piece of software unique and useful. It can set your software apart in the market and help your business succeed.
The key is knowing how complexity affects software projects and addressing that complexity in a smart and healthy way. This allows the software to perform well while being built on time and on budget.