Application Development Life Cycle is the term used to illustrate the comprehensive process encompassing the various procedures followed in application development. It begins with identification of requirements, and going through several constructive stages, the course of action culminates with deployment and maintenance. While the later applies to various developments including high-end information systems and system engineering projects, the former basically confines to software application development.
Application Development Life Cycle is essentially a subset of System Development Life Cycle (SDLC).
The sequences of activities that make up the process traditionally include Planning, Analyzing, Designing, Testing and Implementing. These deliberate stages are usually preceded and succeeded by various other activities. In case of an already existing system, the process would start with a thorough evaluation of the system. On the other hand, while starting fresh, the process is initiated with information gathering from various sources. The initial step is usually preceded by feasibility study, carried out to evaluate the viability of the future steps and the overall developmental activities. Based various parameters like client’s budget, availability of resources, etc., the ideal course of action is decided to entail the scope of final objective. The process adheres to essential phases, which essentially define the type of model that would be employed. Some of the popular Application Development Life Cycle models include
- Waterfall Model
- Prototyping Model
- The Agile Model
This traditional model is conceived on the ideology that spending enough time early in the development cycle can go a long way in reducing costs at later stages. If a problem gets spotted in the initial stages itself, it would be much easier and cost-effective to fix than in the later stage.
The model employs a sequential process and the progression is viewed as flowing downwards. As this can be easily identified with the flow of a waterfall, the process has come to be known as the waterfall model. The various phases through which the progress in the waterfall model ‘flows’ include –
In the primary phase of conception includes the creation of a requirement specification document. It enlists the overall functional and non-functional requirements. It could also allow the development of ‘use-cases’ that define the various user-interactions that the application is supposed to provide.
The document essentially is an embodiment of various agreements that are corroborated between the client and the development-team. It allows a meticulous assessment of the essential requirements before beginning with the design. It is useful in reducing the unwanted redesigns later and also offers a pragmatic estimation of risks, product costs and time-schedules. The subsequent step is analysis of these requirements and is vital to the success of the project. Also, the requirements are requisite to be actionable and measurable, while being defined under the paradigm of essential business constraints.
In waterfall model, it is common to invest 20–40% of a project schedule in first two phases. The subsequent phases of analysis, design and development go about giving a formative structure to the application. Around 30–40% of the total time is dedicated for these vital stages while the remaining is spent on testing and implementation of the software. Most projects include a detail list of controls and procedures that regulate the overall developmental process.
While waterfall model was process of choice for considerable period being followed by many major organizations, it has now fallen out of preferences. It has been criticized to be highly rigid and sluggish. Moreover, the assumption that clients would exactly know their requirements at the very beginning of the project has been disparaged. Pragmatic options of watching the final product and making changes leads to the overheads of redevelopment and testing, which has made waterfall model unpopular with the development teams. Many modified versions of the model have now come up and being used across the organizations with several variations.
Application prototyping is built on the convenience of letting the end-users evaluate the developers’ proposals for the product by trying them out in essentiality. This is contrary to the traditional process of evaluating the design based on mere descriptions. Prototypes are basically the incomplete versions of the final application and simulates some of it chief aspects. It can entail various benefits as developers can get valuable feedback from the end-users early right at the start of the project. It lets all the stake-holders analyze the specifications in the beginning and match it with the final product. Also, it allows them many insights into the accuracy and scope of the project. This lets the stake-holders estimate the deadlines in a better way and ensure they are successfully met. Prototyping is beneficial in describing unconsidered-requirements which can be a key in commercial relationship between clients and the developers. The following are the essential steps involved in prototyping Identify basic requirements
Requirement gathering: The initial step determines the primary requirements which can be assembled based on the needs of the clients. They can also be procured from the existing system if any.
Prototype Development: The initial item includes only the essential user interfaces. They are based on the details of the requirements gathered in the previous step.
Evaluation: The end-users analyze the prototype and come up with a profound list of feedback that entails the changes.
Improvement: The inputs are utilized to capture the specifications. Based on these the prototype is changed or improved with through constant interactions. As the prototype keeps developing, it evolves to conclude the scope of the project.
Implementation: Based on the final prototype, the developers then set about developing the real product, which is thoroughly tested to conform to the agreed specifications.
The model allows addition of features that couldn’t be conceived earlier, which gives a far better understanding of real application to the clients and the end-users. It can also save cost as all the changes are essentially done on the prototype and not the main product. However, it has its own share of disadvantages as some of the features that evolve during the progression stage might not be in the final scope of the product causing user-resentment. While, developers can go on making the changes as per the feedback provided, the end-users who are not technically qualified might demand features that are not feasible. This could also lead to several disagreements and could cause disengagement between the stake-holders.
Several versions of prototyping model have been developed with an aim to reduce the disadvantages and optimize the process. While, this technique can be considered an overall improvement over the waterfall model, the innovative methodologies developed recently are far more dynamic and pragmatic in the approach. One of the ideal methods currently in vogue is Agile development model.
It is an ideology that aims at evolving requirements and solutions through the combined efforts of cross-functional and self-organizing teams. It endorses quick and flexible responses to amendments through adaptive planning, iterative development and constant improvements. In the agile manifesto that was conceived in February 2001, various ways were discussed to give software development a more humane form. This led to the conceptualization of Working Software and impetus was shifted on customer collaboration and pragmatic response to change rather than contract negotiation, and rigid conformance to a plan, respectively.
While there are several agile development methods, the majority promote customer collaboration, process adaptability and efficient teamwork throughout the life-cycle of the process.
Most agile development methods are incremental, evolutionary and highly iterative in character. They operate by breaking dow the overall task into diminutive increments. This is done with minimal planning and in short time frames iterations (time-boxes) which generally vary in time frame, lasting from a week to up to a month. The iterations involve a cross-functional team performing all types of functions that typical to application development. The functions largely include requirements analysis, planning, design, development, acceptance testing and unit testing. When the iteration concludes, the operational product is demonstrated to the client. This might not have all the functionalities to warrant a release, yet the objective is to have a releasable version ready. While it minimizes the risk, it also helps in adapting to changes quickly. Multiple iterations put together can lead to the release of new versions.
The model usually incorporates a large display located on the shop-floor and acts as information radiator. It provides an up-to-date status of the project in a summarized form. One of the primary disciplines followed during the development include face-to-face communication of all team members. Usually every team includes a customer representative who is appointed by clients. The representative is always available to answer mid-iteration queries. On conclusion of each iteration, all stakeholders analyze the progress. They review the priorities and re-evaluate them to maximize the return on investment (ROI).
One of the popular features of agile development is the scrum. It is a brief session held daily from start to the conclusion of the project. Every scrum is aimed at achieving the team’s sprint goal. All members report to each other about their previous day’s work and discuss the next day’s work. They also discuss and sort out solutions to efficiently tackle the impediments to their team’s sprint goal. These short feedback loops can be constructive in deriving the ideal ways with focus on quality, and adaptability.
Agile software development also uses various techniques to keep the focus on quality. Some of them include –
Continuous integration: The practice involves merging the working copies of all team members in to a shared mainline. Aimed at preventing integration problems, this activity is usually performed continuously over several times in a day.
Unit testing: It’s the basis of component testing, and involves testing code fragments created by white box testers. It involves testing computer program modules and individual units of source code. Operating procedures with associated usage procedures and control data are tested together to see if they are fit for operation.
Pair programming: This agile software development technique requires two developers to work on one workstation. While one writes the code, the other developer concurrently reviews each line of code instantaneously. The observer focuses on the strategic course of the code, infusing ideas to address the future problems. This lets the writer to focus on the tactical aspects of implementing the task.
Test-driven development: The process involves continues repetition of short development cycles. To start with an automated test case that defines a function is created. This is followed by code that passes the test, letting the programmers to create code that matches the acceptable standards. It goes a long way in encouraging minimalistic designing and inspiring the confidence of the programmers. The concept is also applied to improve and debug legacy codes created with older techniques.
Domain-driven design: This technique focuses on complex needs by linking the implementation to an evolving model. Focusing on the core domain logic is the basic premise of this technique.
Code refactoring: The process includes restructuring existing code, modifying the factoring. This is done without disturbing the external behavior. Refactoring enhances the nonfunctional attributes of the application. Enhanced code readability and condensed complexity are the essential advantages, while it also improves source-code maintainability to create a communicative internal architecture to improve extensibility.
While these are some of the various techniques used to improve quality and enhance agility, the Agile model focuses on stable planning and accurate estimates in early stages. Though these might be hard to achieve in the very beginning, the iterative approach towards schedule planning allows the change of scope through flexibility towards changing realities.
As testing is performed during each iteration, every small piece of the code is frequently validated to fit seamlessly with the new pieces. This helps the teams to constantly adapt to the plans so as to maximize the value it delivers.
When the real value of the updated software is deciphered by the users, it helps them to make enhanced decisions about the future of the software.
While agile methods are centered on various aspects of the application development, the main focus is essentially on the practices and the vital aspect of managing the project. However, the approach provides comprehensive coverage over the entire development lifecycle.
- Application Development Life Cycle is essentially a subset of System Development Life Cycle (SDLC).
- The sequences of activities that make up the process traditionally include Planning, Analyzing, Designing, Testing and Implementing.
- Based various parameters like client’s budget, availability of resources, etc., the ideal course of action is decided to entail the scope of final objective.
- Waterfall model is conceived on the ideology of spending enough time early in the development cycle to eliminate errors, which can reduce costs at later stages.
- In waterfall model, it is common to invest 20–40% of a project schedule in first two phases.
- Application prototyping is built on the convenience of letting the end-users evaluate the developers’ proposals for the product by trying them out in essentiality.
- The model allows addition of features that couldn’t be conceived earlier, which gives a far better understanding of real application to the clients and the end-users.
- Agile developmental ideology aims at evolving requirements and solutions through the combined efforts of cross-functional and self-organizing teams.
- Most agile development methods are incremental, evolutionary and highly iterative in character.