HWDTECH

blog

Four problems of software development complexity
and where to find them

What's happen when development turns into a merry-go-round, how programmers put bricks and why you need to "run". Part 1.
10-04-2019
theory, IT, software development
Reading time: 2 minutes
Typical project work in the IT industry sometimes looks like a giant amusement ride, for example, roller coaster.

At first, it seems that we take off! Everything is fine and superhero programmers will find a solution for any kind of problem.

But a little while later active project work often shows that even good ideas can fail. And we have to construct the whole project with the help of crutches.

And then what seemed like a great idea is quickly turning into the invention of the wheel. We are rapidly falling.

In the end, all the project developers no longer even dream about a normal solution but try to assemble at least some kind of wheel hoping it will work.
This ridiculous story lasts until a revolution happens. The current version of the project is abandoned and everything starts from scratch. Alas, no one can give a guarantee that the second attempt will not follow the first one's scenario.
On most projects, this cycle always goes on almost the same way: at
first there were ambitious plans, then something unexpected happens and all decisions are thrown to the trash.

It doesn't look so scary when it comes to a small project. But, unfortunately, it all works for global solutions. Sometimes it is more profitable to write a multi-million dollar project from scratch than to support it and fix bugs.

Can we turn this cycle from a shortage into a feature of the IT industry? Yes.

But first, let's see: IT specialists are definitely not the laziest and certainly not the stupidest people on Earth, but why are projects still failing?
The problem of the hundredth brick
The most important feature of IT is the problem of complexity. You can learn more about it, for example, in the book "Object-Oriented Analysis and Design with Applications" written by Grady Booch.
Alas, this complexity we speak of seems to be an essential property of all large software systems. By essential we mean that we may master this complexity, but we can never make it go away.
— writes Grady Booch.
What do such ominous words mean? In fact, complexity means the following: the amount of resources, connections and components that are required to solve a task grows non-linearly as the size of the project increases.

Let's look at this statement by example: imagine the work of a bricklayer and a programmer.
If a bricklayer builds a wall, we can expect that he will put the first brick, for example, in 2 minutes, the second in 2 minutes too, and the hundredth brick he will put faster, because he has developed the skill and got experience. By the thousandth brick, he may become a virtuoso and will do everything at lightning speed and with his eyes closed.
And what about the programmer? All things are different. The programmer puts his first virtual brick in 2 minutes, the second in 2 minutes, the hundredth brick he puts for some reason in an hour, and the thousandth in three days ... Why? This is just an illustration of the problem of complexity: the project grows, needs change and, accordingly, the necessary effort, time and labor costs grow after it.
Simply put, in IT we can start the project together in the garage, and in the future, thousands of people will be involved in it.

More precisely than Grady Booch, the problem of complexity was formulated by Lewis Carroll in "Alice Through the Looking Glass", where the Black Queen says: "My dear, here we must run as fast as we can, just to stay in place. And if you wish to go anywhere you must run twice as fast as that."

Unfortunately, this is the cause of other unpleasant things: the fact that programmers fail to meet all deadlines, the fact that everything is not going according to plan, that the industry is constantly suffering from staff shortage and so on.
«The more complex the system, the more open it is to total breakdown». Rarely would a builder think about adding a new sub-basement to an existing 100-story building. Doing that would be very costly and would undoubtedly invite failure. Amazingly, users of software systems rarely think twice about asking for equivalent changes. Besides, they argue, it is only a simple matter of programming.
— Grady Booch.
Also, because of the problem of complexity, today everyone is interested in the philosophy of Agile: it is difficult or impossible to plan the work of programmers in the usual way, you just need to look what they do and find value in it. The reason for this is that costs will grow nonlinearly and it is necessary to have time to do at least something useful for the available money.
«A further complication is that the requirements of a software system often change during its development, largely because the very existence of a software development project alters the rules of the problem», - Grady Booch.
Agile is more and more like this today. We don't waste your money, we spend your money with benefit, don't plan anything beforehand, but fortunately, something good happens as a result.
Programming demonstrates several kinds of complexity problems.
In the next article, we will discuss directly 4 manifestations of the problem of software development: algorithmic complexity, development complexity, information complexity, and testing complexity.
Once a month we make a newsletter with the announcement of new cases and articles published on the site.
Sign up for updates.
Guaranteed: no spam. By clicking on the button, you consent to the processing of personal data and agree to the data protection policy.