Advantages of efficient software development methodology

1.  Since significant effort is put into recording and analyzing customer’s needs and producing a requirements document, the chances of large requirement changes should be minimal during a phased delivery which increases confidence that each delivery will be on time.

2.  The length of time between deliveries is longer compared to most agile methods, which reduces costs since delivering software has overhead associated with it.  Some requirements changes are allowed up to a certain point in a phase, but then are moved into the next phase when it is decided that new requirements will endanger the delivery.  Another benefit of using a longer delivery time is that much more useful and meaningful functionality can be provided to the customer.  Compared to, for example, 52 1-week deliveries that do not provide much functionality for the first few deliveries and can actually annoy the customer by wasting his time.

3.  The developers always know where they are going.  Developers are not left to just start coding in some direction based upon a feature request card.  A functional specification document is produced as well as pseudocode which is used to design the software.  The hard and tricky parts are conquered first.  After this, it is relatively easy and straight forward to code.  Producing a requirements document, specification document, a design document (pseudocode)/diagram gives the developer ample opportunity to think about the code and design the code well from the start.

4.  Developers own their own code.  They are the go to person for bugs and new features.  When a developer owns the code, it means that he does not have to spend any time reviewing and analyzing what other developers have done to that code.  The code will also be more consistent since it only has one author.  This means that bug fixing and code changes can be done faster and more efficiently which saves time and money.  The style and design of the code is much more likely to be consistent with only one developer.vs. 5 or 10.

5.  Each developer has a backup developer.  If a developer leaves the project, is sick, goes on vacation, etc. the backup developer is in a position to take over that code.  The backup developer also can assist with requirements analysis, design reviews, code reviews, and mentoring a new developer to take over that component should the original developer leave the project.

6.  No incremental integration.  The developer focuses on writing the code for a few days at least and then does testing after all the code is completely done.  So, there is no overhead of checking the code in and out and doing integrated builds / tests several times a day which is what happens in some agile projects.  This is a huge time saver which leaves the developer free to focus on the design and implementation of the code.

7.  Developers usually work alone when designing and coding.  This means they are free to concentrate for extended periods of time and take advantage of flow which means that they will produce better code faster versus developing in an agile environment that requires pair programming.  Some developers will show that they can finish programming assignments incredibly fast because of flow.  See the problems with agile practices topic for more information on this topic.

8.  All of the code is written first before any test is written.  The advantage of this approach is that the testing baggage is put off as long as possible so that the developer can focus on designing and writing the code and not spend any time on the tests until all of the code is written.  Another advantage is that the developer is free to focus on thinking about if there are any missing requirements, if the code meets the requirements, the best design for the code, and the implementation for that code.  Focusing on testing too early can get in the way of these very important activities.

9.  Testing starts off with line by line testing in debug mode.  Every path is tested, with the developer verifying that each statement does what he intended.  The advantage of this is that it provides a second chance to refactor the code and consolidate similar functionality into new methods as well as provide much confidence that the code works as intended.

10.  Unit tests provide the advantage of automated regression testing.  This means that when a change is made in one part of a component that caused a defect in another part of that component, then there is a good chance of catching that defect before it is checked in.  Unit tests may use test stubs in order to run the tests quickly on the developer’s machine.

11.  The advantage of not having the developer run the acceptance tests before checking code in is that it reduces turn around time for building and testing his component, which increases developer productivity.  The developer has more time to focus on design and code .vs. testing.

Prev          Next          Back to efficient software development home

Copyright 2011 by Robert G. Bryan

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