There's No C in DevOps, But There Should Be
There's No C in DevOps, But There Should Be
No, not *that* C. Software is built by human beings, and how those humans interact with each other matters.
Join the DZone community and get the full member experience.Join For Free
The ‘C’ Word – Culture
I confess to often talking about the need for culture-change in software development organizations. I hope though that what I mean is something more concrete.
Software development is an interesting human activity. It is technically complex, we create the most complex systems (apart from other human beings) that humans have ever produced. It is fragile, there is little in human experience that is quite so intolerant of tiny errors as software. Every piece of software that we create is an exercise in discovery, if it wasn’t we would just re-use what we had from before. It is a creative discipline in both the literal and figurative sense. We do this in collaboration with lots of other people and the fate of the organizations that we operate in often rides on what we build.
The trouble is that, as an industry the software development industry has rarely delighted its users. This isn’t really a problem of software itself, but rather the ways in which we have undertaken its development.
We can all think of examples of great software done well, but in nearly all of those cases, the way in which these “exceptional development teams” approached the problems that they faced was different to what most of us have been taught and what the majority of organizations that create software do.
In practice, it is my opinion that the majority of our industry has grown up doing things in inefficient and ineffective ways. This isn’t a small thing. This isn’t a “buy this technology and it will make it all work” kind of problem. There are some very basic, very fundamental things that you need to get right for software development to work effectively. In large part, this is at the level of the ‘Culture’, there is that word again, of the organizations that want to create great software.
If software development projects were normal things then we would expect to see as many projects finish ahead of schedule, below budget and exceeding the expectations of their users as projects finishing behind schedule, over budget and disappointing or being ignored by their users.
We would expect to see a “normal distribution”, the blue line in the diagram below. (See Figure 1)
Instead I believe that we have come to expect, in most organizations, something more like the red line.
We have built an industry that assumes that late delivery, cost-overruns, low quality, and features that users don’t like or don’t want is normal. This is crazy! These are not essential properties of software development.
I believe that what this is telling us is that we have got this badly wrong. We have entirely the wrong model for how software development should work.
It is a bit like this (http://www.malinc.se/math/trigonometry/geocentrismen.php). When people thought that everything rotated around planet Earth, geocentricism, then it was impossible to imagine how the complex paths of the planets could arise. As soon as you change perspective, in this case to heliocentricism, you get to think about the problem differently. All becomes clearer and simpler. Now we can reason, now we can calculate, now we can predict. Now we can evolve the next step. Newton can describe the inverse-square law, Einstein can later describe warps in space-time. Without that first step, of discarding a viewpoint that makes the world look more complex rather than less, progress is stalled.
We have grown a culture around software development that does to software development what geocentricism did to cosmology. We can’t see the beauty and simplicity because it is hidden by the complexity of our own creations and assumptions. This isn’t just about how we write code or how we manage deployments or even whether or not Developers and Operations people sit together. Rather this is about how the whole organization thinks about change. How we constitute and organize teams. How we apply governance to projects. How we regulate them. It is about how we deliver new ideas to our users. This stuff is fundamental.
I argue that all organizations that create software want the same thing. They want to have an idea. Get that idea, in the form of working software, into the hands of their users and see what their users make of it.
This is my definition of what Continuous Delivery is all about. This is more than a tool or a process. This is a change in the whole culture surrounding software development.
I think that one form of geocentricism is project-based working. The data is in; we are terrible at predicting the outcome of software projects! So maybe the idea of software projects is wrong. If we look at some of those “exceptional development teams” they don’t very often have a project focus. Instead they are in it for the long haul, they are focussed on products and look after the software for its whole life. If we change our culture to think of an on-going relationship with our software and our users, things start to make more sense.
Cross-Functional Teams and User Acceptance Testing
Projects lead us to think in terms of budgets and timescales. What if, instead, we did all of our work as a series of small, maybe even tiny, changes. We could quickly decide if each change is worth a try. Maybe we could even do simple versions of a change to see if our users liked it, thus avoiding costly development of features that no one ever wanted.
How do we cope with big problems? We subdivide them. Mostly though we sub-divide them along technical boundaries or job-function boundaries. This creates silos and breeds a whole raft of complexity to surround it. Do you work in an organization with front-end and back-end development teams? How about a separate QA or Ops team?
As soon as you organize like this you have built a cross-team dependency in to almost every new requirement.
How about we change our culture. Instead of dividing our teams by technology or job function we establish cross-functional teams responsible for an independent area of the business. In such an environment each new requirement usually has a natural home in one team. This simplifies the work of planning, but also simplifies the work within the team. Allowing them more autonomy and enabling them to make decisions that will make them more efficient and improve quality, or even just meet their users needs.
I once worked on a software project where the development team was disbanded before User Acceptance Testing was carried out. Cargo cult process of the highest order! So there was an expensive, slow, late, manual process to evaluate whether or not the software that the team had built was fit for purpose, but there was no development team, except for me and two others, left to address any concerns. Had the users decided that we had completely misunderstood some key aspect of the system there was nothing we could do about it.
How about we change culture, instead of waiting until the end to see if users are happy, why don’t we ask them as soon as we possibly can? If we can deliver new changes to them quickly then we can learn from them. If the nature of our software is such that we can’t do that, then we need to find a, simple, alternative. Maybe we can have representatives of the users on our team using the software all the time as it is developed?
You can’t “inspect quality in to a product”. Quality is “built-in”. User Acceptance Testing, in fact any form of manual regression testing is another of those assumptions built in to our industry that needs challenging. Instead of looking at code after it is finished, how about we think in terms of “Executable Specifications” for the behavior of our systems. Let us not waste time defining the behavior of our system in a document. Let us instead, make those definitions Executable and run them every time that we make a change to our software so that we can be certain that our system still fulfills its needs. Get developers into the loop and get them thinking of asserting the behaviors of the code that they write as they write it.
If you have read anything about Agile development or Continuous Delivery these ideas should be familiar to you. But make no mistake, this is a culture change. We need to look at software development and think again. We need to challenge the assumptions that constrain us. It is *not* acceptable or normal to have hundreds of bugs in production. It is not an inevitable characteristic of software. We can’t plan reliably, so let us work in ways that don’t need us to.
These ideas are not new. I believe that if you look at the history of outstanding software development, then it won’t be planned, waterfall, manually tested. It will be evolutionary, incremental, experimental and iterative. It will have been carried out in a manner totally alien to the majority of software development process in our industry. Success has been an outlier that required people to break convention. Let us work to make that success curve more evenly weighted.
It is time to change the culture of our industry.
Ready to make some enterprise changes in 2016? Learn from the best with our on-demand “Top Enterprise DevOps Lessons For 2016” by Andrew Phillips.
Published at DZone with permission of Dave Farley , DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.