Core Agile Software Programming Practices

Agile programming involves producing a working, tested piece of software every iteration- depending on how long your sprints are could be 2-4 weeks. This can be very demanding at times but if you adhere to the core practices of agile software programming then you should be able to produce good quality software/features each iteration. The core agile software programming practices are the following:

Test Driven Development

In agile development test driven development (TDD) is very important due to the pace in which software features are produced. TDD allows developers to ensure the code they have written isn’t error prone; this is through developers writing the tests before they code (unit tests). These unit tests need to be passed before code can be migrated to a higher environment meaning that the developer can be confident that his code is working as it should.

Continuous Integration

Continuous integration require developers to ingrate code into a shared repository often through out the day. Each commit to the repository should set off an automated build. This build will run through a pipeline with different types of tests (unit, integration, validation, etc.); Although, our unit tests passed we are only testing our code standalone, as we integrate our code with other systems there could be failures in our integrated tests. If we run these builds often we are able to detect errors earlier rather than commit once all the code is done and waste time back-tracking to see what went wrong.

Simple Design

The four rules of simple design are:

  1. Make sure all test pass
  2. Express developers intent
  3. no duplication
  4. minimize the number of class and methods

Simple Design means coding for the specified requirements and what the customer asked for, there’s no need to build added functionality: this could bring unnecessary debugging. In an agile environment we should keep our design simple and understand that design is an ongoing activity and is subject to change.

Pair Programming

In an agile environment it’s important to have pair programming activities as it’s a good idea to have another pair of eyes over your work. Pair programming has it’s benefits and drawbacks. For further information on pair programming have a read of our pair programming blog.

Coding Standards

It’s important that all developers adhere to a coding standards as it can become difficult to maintain code. When another developer inherits an code there isn’t anything worst than wasting time trying to understand what is going on. Often developers will have to write the code again in a way they feel is right. If all developers understand the coding standards then it’ easy to add, maintain and debug code. Likewise, all developers should be sharing the same code base as there are no conflicts in working versions.

These practices allow the team to be flexible thus, catching bugs earlier in the development life-cycle which in turn allows robust software to be implemented. The developers can have confidence in what being produced as it has gone through the necessary procedures.



Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s