[a_square_peg]

On the other hand, simplifying an already over-engineered product is almost next to impossible simply because many jobs depend on it. Maybe I'm cynical but I'm beginning to think that software complexity grows until it justifies all the head counts in the department.

[darepublic]

Yeah it is like this. Even simple sites require a ton of engs thrown at it. On the business side I guess they figure spending more money on tech will make them safe, but it's like of you wanted a bowl of soup and hired ten chefs to do it. But I can't complain since I am one of the soup chefs, and I help make sure we have tests that prevent the soup from becoming too salty

[darkerside]

This is the same phenomenon as the Peter Principle, where people Rose to the level of their incompetence. It sounds like a joke at first, but, of course they do. People get promoted when they excel. When you are in over your head, you stop getting promoted. Of course, over time, people grow into their roles, and regain their competence.

Devs will build software until they can no longer do so because the codebase is larger than their collective abilities to manage.

[Griffinsauce]

> Devs will build software until they can no longer do so because the codebase is larger than their collective abilities to manage.

I'm developing a principle of radical simplicity to attempt to combat this: always keep things absolutely as simple as they can be.

It is always easy to add complexity later, never to remove it. So the only conscientious choice you can make is to keep things as simple as possible while satisfying the requirements.

You should also critically evaluate requirements that introduce complexity.

Also, I don't think people mention this enough here: complexity == bugs.

[FpUser]

Ability to keep things "simple" (basically produce code / architecture that is easy to understand) when solving problems in business domains (which usually are very complex in real live) is an art that few can successfully practice.

[axiosgunnar]

Exactly. It's actually very very hard to write simple code, no matter the problem at hand. It's easy to write convoluted, complicated code.

[steve_gh]

It's a well known phenomenon studied in Complexity theory - and it is called "Evolution to the Edge of Chaos"

[a_square_peg]

This is both interesting and disheartening - the evolution would concern itself more with the software organization then the product (hence the product death).