When an organization makes that decision to shift to agile development and project management practices, no one says it’s going to be an easy transition.  New developers coming in might already be trained or might make an easier transition to new practices.  However, experienced developers who have always been doing it ‘another way’ may have a much more difficult time modifying how they think about projects and development efforts and rollouts in general. 

When an organization is shifting to agile practices, existing developers often raise concerns – wondering how they are supposed to write code in an environment that involves shifting requirements and there seems to be little or no architecture.  These are concerns that need to be addressed of course – they are legitimate concerns.  In order to address them, it involves gaining knowledge of the agile development process and also getting the developers to acquire the skills needed to thrive in an agile development and project environment.

Let’s look at some of those key skills that are required to make a smooth transition…

Keep the system in a running state.  Finding errors is a huge time waster for developers.  When changes are happening and something goes wrong, it’s hard to know what caused the error – and it takes time.  By making incremental changes to detect errors immediately, this saves a lot of wasted time normally spent on search and destroy activities concerning bug fixes.

Minimize development complexity and, ultimately, rework.  The idea here is to move away from over-design (which causes complexity) and hacking away at the code (which causes re-work).  This is more of an attitude change than a skill set.

Separate use from construction.  This one is important as it eliminates the situation in which integrating new code into established systems exceeds the cost of writing the code in the first place.  It actually forces abstraction and encapsulation onto the developer…which is a good thing in the agile development world.  It provides discipline for  hiding the specific implementation you are using.

Define tests up-front.  It’s critical to define tests up-front even if they aren’t written up-front.  It definitely increases understanding and can certainly help prevent many errors in the long run.   Testing, of course, involves more than just discovering bugs.  Testing helps discover the causes of errors and allows the developer to eliminate them.  Testing helps make clear the assumptions and requirements that customers have without getting overly technical.  Testing ensures code integrity and compatibility with other code modules.  And it can help to minimize risks caused by humans, machines, and the environment.  Testing is critical and the ability to define it up-front is a critical skill to acquire.

Continuous Integration.  Continuous integration is not likely a skill that existing developers have and it’s not a mindset that they have been working in over the years.  This is critical to agile project management and agile development – and it is a low cost way of detecting errors early and quickly.  Also, it is essential if you are writing your tests up-front as mentioned above.

Summary

The switch to agile project management, agile development – and agile thinking, in general – is not necessarily an easy one to  make.  It certainly takes some time, likely some monetary resources, a learning curve, some pain and probably some resource replacement.  In the end, it can be very rewarding for your organization and for the customers you serve in terms of project successes.