Of Gods and Procrastination: Agile Management
Of Gods and Procrastination: Agile Management
Common errors in Agile management, and how to get the best quality code from your developers without tying them to their keyboards.
Join the DZone community and get the full member experience.Join For Free
You've been hearing a lot about agile software development, get started with the eBook: Agile Product Development from 321 Gang.
The year was 2001. A new methodology appeared in a still young, yet maturing industry of software development. It came with the Agile Manifesto. The new way, the Agile management way, came to break the old, strict, narrow and deep hierarchy in which the developer was way too far from the software’s user.
Quickly embraced by some, completely ignored by others, Agile management spent the last decade and a half gaining popularity. Today it has become one of the most trendy phenomena, and most companies claim to have adapted and applied its principles. And indeed, that is true, yet almost always in a modified, and even sometimes in a corrupted, way.
Most of us in software development have been in different teams and projects, as developers in some, and as team leads & managers in others. We coped with clients in kick-off meetings, decoding acceptance criteria and wireframes, defining the MVP, accepting changes in the requirements, and modifying the scope in the middle of the sprint. We made mistakes and learned the hard way. Mistakes that we should not commit again. Yet sometimes, we see them happening again in our own team, when visiting clients, or meeting teams with whom we will collaborate, etc. Today, I want to focus on the troubles I see the most among managers with software developer teams.
Agile Management Common Errors
Meeting a Tight Deadline by Adding Additional Resources to the Team
You check the estimation for the running sprint and find out that the team is currently 16 hours behind the schedule. It seems like no problem at all; you have a developer that just finished his project, he will join the struggling team for two days, and you guys will be back on track.
By doing this, the team probably won’t meet the deadline. Why? The mistake here is to think that a developer performs easy, automatable work. Well, he doesn’t. Even if he is familiar with the technologies used in the project, he still needs an introduction to what the project is about, what has already been done, where all the documentation is, what wireframes are still being reviewed, and a very long list of other things. Besides the fact that the productivity of this developer will be low (at least in the beginning), he will also need to be assisted by the rest of the team to be taught everything described above. A task that is usually assigned to one particular person. Well, that person’s productivity will also drop as he will be distracted and will have to spend hours helping and training the new member of the team.
In the beginning, Parkinson’s Law had a different meaning. Today it states that work expands to fill the time available for its completion. Let’s say we are having a performance issue with a particular project. So we assign one of our best developers to investigate what the problem is and to fix the bottleneck. To do that, we decide to spare a week of time.
Parkinson’s Law is not always present in a developer; sometimes it’s stronger, sometimes it’s weaker. Yet freedom of time in a task, especially if it doesn’t have a clear where-to-end point, will lead to its expansion, occupying all the time available for it. Sometimes it can even be worse, where the resulting solution suffers from over-engineering that adds unnecessary complexity to the project. To avoid this situation, the task must have strict goals and acceptance criteria, or otherwise, a frequent polling in order to see the results achieved so far.
Multiple Projects and Distributed Teams
Although out there you can find an enormous amount of articles on how to succeed with distributed teams applying Agile, keeping in mind an even distribution of tasks, understanding time and cultural differences, etc, not all projects are good to do such a thing. Especially when each developer forms a part of several different teams at the same time. In the attempt to make each one of the developers an ‘all-terrain’ developer, they end up working on multiple projects at the same time; for instance, Monday and Tuesday on project A, and from Wednesday to Friday on project B.
You have probably heard about the developer’s focus. This is when the developer is in their most productive state of mind. Once they lose that focus, however, it takes some time to get it back. Well, the same thing happens when switching between projects and checking what was missed while being away. Although some tools help to mitigate this effect, Dailies, Jira or Trello, for example, it still drags down one’s productivity.
It’s easy to disagree about this topic, but by default, I do defend the 6th principle of the Agile Manifesto, for both ‘co-location’ and ‘co-time’:
“The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.”
Time Pressure Increases Productivity
It’s surprising how common it is to discover among your co-workers and professional colleagues that they had the same dark experience. Often in a startup or in a small company, with a very talented manager that made them ‘believe in themselves and in the product,’ which ended up in countless extra hours, tons of stress, and impossible-to-meet deadlines. As developers accept such working conditions, it allows their manager to presume that the team is quite productive, as the ratio of delivered functionalities and time is unbelievably high.
In fact, the productivity of the team might be considered high, as long as you don’t take into account the quality of the work done and the extra (and unpaid) hours. Those kinds of conditions inevitably lead to two results:
First, the quality of the code goes down hill. This means more bugs passing through (no need to explain that a bug in production is hundreds of times more expensive for the company than the time needed to get it done right in first place), the test coverage fails, functionality is implemented partially, etc. Under time pressure, developers won’t work more, developers will work faster. Basically quantity over quality.
Second, at a certain point, the developer ends up quitting. Once he realizes that things won’t change and that his workaholic attitude and commitment to the company isn’t really good for him, he will definitely find another place to try his luck. Usually, the one that leaves is the one that had the most pressure, i.e. the one that can actually leave because he knows he has another option. And guess what? That’s the developer that you can’t let go.
To finish with this paper, I would like to point out the link between the code of a developer and his motivation. Usually, Software Development is not just something that ‘pays the bills,’ it’s someone’s passion. For a developer, to have the chance to write quality code means a burst of motivation. Take that chance away, and the motivation is gone.
And when a manager’s focus for the team is to keep up the productivity, the quality rarely increases in a significant way. When the focus is on quality, however, productivity tends to soar.
Published at DZone with permission of Roman Predein . See the original article here.
Opinions expressed by DZone contributors are their own.