The edge of chaos is where life has enough stability to sustain itself and enough creativity to deserve the name of life. M. Mitchell Waldrop

When software development is bad, it can unscramble an egg.

In the book Complexity: The Emerging Science at the Edge of Order and Chaos can help you understand complexity.

Creating software is complex, there are interrelated requirements that combine to create software. Software development teams need to find an effective way to work with customers who have different levels of technical knowledge and business knowledge.

Any process that involves lots of people collaborating will be complex and on the verge of chaos on a weekly basis.

Software development teams tackle software projects can lead to an ordered approach or chaos development.

Software At the edge of chaos

Software development teams and software projects can go from order to chaos fast. The difference between well-structured project and a chaotic mess can be small.

The difference is usually successful projects have a strong senior team (Solution architect(s), Lead developers(s), Project manager(s), Scrum master(s) and other leaders) who set standards, processes, control the scope and keep everything on track.

Good development teams

What is order and chaos?

• Chaos is random unpredictable events
• Order is precise predictable events

Complexity is chaos and order combined to create a process that lets a development team create software.

Software projects and the development teams processes in terms of chaos, complexity and order

Chaos

The more chaotic a project is, the worse it’s managed.

The more chaotic software development processes is, the lower the quality of software and the more problems occur.

Chaos is a great way to describe bad development — What Happens When Bad Developers Create Software -Development Chaos. When you start on a chaotic project, the goal is.

Stop it from getting worse and start to make it better

On a chaotic project, you see developers working hard but there is no organisation and nothing makes sense. It's almost as if you can’t trust your what you are seeing because it looks like development, but more software creates more technical debt and more problems.

Everything on the project will be chaos. It’s out of control and no one is sure why or what to change to bring order.

• Requirements are chaotic and constantly changing
• Builds, deployments are manual
• No standards.
• Developers do things differently
• No documentation — information held in people’s heads or local machines

Initially, you aren’t sure why the actions on the project are causing so much confusion, chaos, and problems. It seems similar to ordered projects but its the subtle effects of no standards, processes, best practices or ordered way of doing development.

Complexity

Complexity is groups of order working together. Complexity comes from the multiple ordered groups, interrelated and dependent.

When you work on large projects, complexity is unavoidable, but you bring order to cope with it.

How do you make complex software simple?

• Create standard approaches that are documented and understood
• Consistency in all development
• DevOps to automate and create consistency
• Enforcement of standards and consistency with code review
• Documentation is a pain, but everyone does it
• Control requirements

The senior members of the project communication progress with dashboards, reports, meetings. This defuses problems and builds trust on the project with progress.

Senior project members stop problems before they happen and resolve quickly. Good senior people step into problems, seek them out, solve them when they are small issues, and give everyone plenty of time to get the work done.

Low quality code is created when development teams are pressured to go fast, senior teams buffer the development team from the pressure and push back.

Senior team members protect the development team and let them create software without distractions or panic.

When chaos hits you in the face

I remember joining a project which I knew was going to be bad. The last words from my manager was

There is nothing you can do that can make this project worse, so go and make it better

It was chaos in full flow. There were 20 to 30 developers/consultants changing things in their own way, overwriting each other and few knew what was going on.

The build and deployment would break regularly and couldn’t be fixed for days.

Problems sprouted from everywhere and in surprising places. It was hard to identify the cause and who should fix it.

A manager told the development team to give the customer whatever they wanted, so the requirements were constantly changing.

The chaos overwhelmed me. The surprising thing was everyone was busy and everyone was working super hard. They were busy like ants and working in a chaotic development environment.

Software development team were trying to out work their problems, poor leadership and lack of development process. This approach was failing, and the project was getting worse and falling further behind each week.

They were trying to out work their poor development practices. Chaos development is a doomed spiral. The more software you create the more technical debt and problems you create.

The more low quality software you create, the harder it gets to create more. Low quality software is complex, hard to understand/change/update/bugfix.

The bigger the project the more important quality and order is. Size magnifies and highlights poor development practice and problems. Developers can work on small projects but a much smaller

Order emerges

Software development processes evolve. Processes and standards emerge in a software project. A well functioning software project doesn’t stop to look for imperfection, it creates a process and tweaks it to be easier and better.

There are many people who contribute to order on an effective project, it’s not just lead by one person but the ideas of everyone involved.

How can I make it worse

Charlie Munger recommends inverting problems, to allow you to understand what you should first avoid before you try to make it good.

In software development, you want to avoid low quality, problems and chaos. So if you purposely tried to make a software projectworse,e you would

• Get all developers to write code differently
• Lack of testing to find bugs in production
• Agree to impossible deadlines
• Create software that creates more problems
• Keep changing requirements
• All developers work agaisn’t each other
• Never write any processes down
• Keep knowledge in your head and then developer leave
• Take shortcuts and create low quality software
• Manual deployments
• No communication between developers or teams
• No trust between customer and development team
• Leaders who don’t understand software development
• No senior developers, lots of junior developers
• Developers with no experience in the technology they are using

If you implement many of the tips above for creating a chaotic project, then you will treat yourself to a crazy project with exiting problems, missed deadlines and long hours.

Conclusion

Good software development teams manage complexity and create order. This generates steady momentum, everyone is clear about what the processes is and what they need to do.

Bad Developers Think It’s Turtles All the Way Down and believe software projects run on magic.

Software development runs on consistency, simplicity, standards, automation and people working together to create smooth momentum. Ordered software development is not too fast, not too slow but smooth.

Slow software is smooth and smooth software development is fast (borrowed from Navy Seals — Slow Is Smooth and Smooth Is Fast)

The shortcut in creating software is to create quality and create it once