1. Introduction
   

 

Software Development Life Cycle can be a workflow kind of a process that defines the main stages and the software development cycle activities. System analysts usually use the SDLC in designing, planning, and implementing the software. With many development methodologies, it actually poses a difficulty in choosing the most appropriate method that one can use. Sometimes the methodologies force for the strategy mix and match multiple implementations of the strategies.

The original concept of SDLC first originated in 1960 when there was a need to develop large functional business systems. Computer programming for the model development of complex things was only done in the manufacturing and construction industries during this era. Therefore, it makes a lot of sense that structured approaches that were adopted in those industries incorporated for better models of software development.  In 1970 the biggest business analysts, most of the manufacturing and construction industries, got into the field of computing so as to analyze the requirements of the business and develop new systems. This gave rise to a group of engineers who recognize themselves as programmers. In these ancient times, programming was very difficult as it was complex, and the programming languages were not an easy thing to learn and manipulate rather.

Computer system development, therefore, follows the structured sequence approach, which made a lot of sense. For years now, computers have even taken important roles in all spheres of life, i.e., sending and receiving emails, conducting auditing, filing papers, and spreadsheets applications. Therefore so many companies take it seriously and spend huge amounts of money and resources on information technology, governance, and security.

Software development concepts evolved after about five decades with new designs and perceptions, which has enhanced the customer-oriented applications to provide much-needed solutions. However, it is unrealistic that no solutions can fit millions of industries and organizations that exist todays due to the fact that organizations have different structures, responsibilities, desires, and goals. However, the shared aims of every organization can be experienced. There should not be a variation in the works described, managed, and organized with different organizations’ requirements and backgrounds. Therefore, modern software development lifecycles tend to be adequately flexible and can be used in various types of business entities, services, or products. There is various software development models lifecycle that can be adopted in the software development lifecycle.

Waterfall

Iterative

Agile, rapid application development

 

Statement of the problem

The software development cycle entails a number of processes and models, which both lead to the development of good and flexible software. However, before adopting or using any model first, the developer should understand what the models entail. Up to date, there is no perfect model and a model that can be said to be standalone. Developers need to match up multiple models or methodologies to achieve desired or set the functionality of the software’s he/she is developing. This poses a challenge, therefore raising the costs of developing software as well as accompanied by resource spending.

Relevance and significances

Software development life cycles entail detailed steps and important activities. It describes how a developer should design, maintain, develop, replace, enhance, or test and restore a given software in need. This study is significant because it pinpoints the detailed activities that can be split into very detailed levels or groups. This includes planning, designing, developing, testing, and finally deploying. This summarizes the whole life cycle of software development. This approach can be graphically represented, as shown in the figure below.

 

 

 

Plan

 

 

 

 

 

Deploy Design

 

 

 

 

 

 

 

 

 

 

Test Develop

	Figure 1 – S o f t w a r e D e v e l o p m e n t C y c l e

 

 

 

 

 

The problem of model matchup and multiple applications, if solved, plays a major role in reducing software development bugs, which are normally experienced due to failing match up in programming while developing the software. This issue spread in scope up to impacts related to the reliability and security of the software.

Research questions

 

1. What are the phases of iterative and waterfall methodologies of software development lifecycle available?
2. What are the disadvantages and advantages associated with such models of software development models?

Research objectives

• To determine the phases which involve the iterative and waterfall model of software development life cycle?
• To investigate the pros and cons associated with the methodologies of the software development life cycle.

 

Barriers and issues

The software development life cycle can be faced with a number of barriers in adoption and implementation more, which can be avoided. The software development life cycle process is a complex product software development that comes with its own challenges, which can be addressed immediately to reduce the impact that will have on the end product. The barriers and issues under this study involve the process complexity, which projects constant change in the environment, for instance, the stack overflow developer survey, which has resulted in the development of products with unspecified requirements. The requirement gathering incurs more than just when the business consultants teaming up and developing a product that will cover the entire project. Issues further related to requirement outcomes and software expectations may just need a solid process of one-line communication. This will ensure the process enhances the software’s quality and ensures the whole development process is covered by good practice.

 

CHAPTER TWO – LITERATURE REVIEW

INTRODUCTION

In the present day world, computer usage has increased greatly as compared to previous years. These computers require software to function correctly, and to develop software, models are required. Software Development Lifecycle (SDLC) refers to the models that help in the development of this software. It comprises of the step by step process undertaken to make the software moving through the lifecycle phases. These models include Waterfall, Incremental, Spiral, V-shaped, RAD (Rapid Application Development), and agile models and will be discussed in brief below.

 

The various SDLC phases include; Requirement definition, Design, Coding (Development), testing, and Maintenance, collectively known as the lifecycle of software.

 

Software Development Lifecycle (SDLC) Models

 

1. Waterfall Model

In this model, steps follow each other consecutively one after the other after the previous is completed.

 

2. Incremental model

In this model, the linear sequential model components are put together with the repetitive philosophy of prototyping. The first increment in this is a core product in that auxiliary features are left undelivered while introductory needs are addressed, after which the next plan is established.

 

3. Spiral Model

This model bears some similarities to the incremental model and is more focused on risk analysis. It comprises 4 parts, which include; Planning, Risk Analysis, Engineering and Construction, and release. Software being developed passes through these phases several times, corresponding to different spirals in the model. It begins with the first phase, where requirement gathering is done to help with the planning. After this, the risks encountered are identified, and possible solutions are brought forward to counter them. The engineering phase is then undertaken, after which the software is tested and produced. The last phase is whereby the produced software is evaluated by the customer to confirm its functionality.

 

 

4. V-Shaped Model

This is known as the verification and validation model. This model, similar to the waterfall model, follows a sequence whereby only after a phase is completed can the next one begin. The difference is that while the other testing is done after the development of the software is completed here. Software testing is done simultaneously with the development phase.

 

5. RAD (Rapid Application Model)

In this model, the attention is mainly centered on the output, which is of better quality and takes less time to produce. Elements are produced parallel and delivered fast. This makes it easier for a customer to use software sooner and request for any desired changes to be made if necessary. Therefore, the developing team produces a functioning model in less time as compared to other models.

 

6. Agile Model

This software was introduced in 2001 by the agile team. It is mainly used for the early and uninterrupted delivery of software. This, in turn, leads to client gratification. Its main Imputes include;

• Incremental- Minor software is produced, attended by rapid development cycles.

 

• Co-operative- More client-developer interaction

 

• Adaptive- Whippy was enough to conform to immediate alterations.

 

Stage 1: Plan

This stage arises from needs or opportunities identified by a group of businesses, end-user, or a sponsor. At this point, the exact nature of the concept has not yet been defined and is basically a concept waiting for its boundaries to be defined. The development team’s senior members will conduct a product feasibility study in financial, technical, and operational areas with input from the business users. During this stage, Quality Assurance and Risk Management plans are prepared to minimize any unpredictable risks. At this stage, Business Case Documentation (BCD) should be ready to summarize all the ideas and have a holistic view of the entire plan.

 

Stage 2: Design

A clear definition of requirements is necessary to start product design. All the details of the product requirements are contained in the Software Requirements Specifications (SRS) document, which should be approved by the client or customer before the product design begins. Based on the SRS requirements, more than one design of the product architecture will be produced. The team’s junior members will document it in a Design Document Specification (DDS) and pass it to the senior members and project stakeholders for review. Various criteria will evaluate the DDS, such as budget, time, user-friendliness, risk, integration, etc.

 

Stage 3: Develop

During this stage, implementation starts immediately after the most suitable design has been selected. Programmers use coding standards as a guideline for developing the software according to the DDS. To align their works, programmers should also ensure they limit their programming tools to those provided by the company. Functional Specifications (FS) should be written by the programmers to record all the functions provided at a technical level.

 

Stage 4: Test

Testing software is a process that should be done during all the stages of development as a sub-stage. However, two major tests should be conducted by programmers, end-users, and quality assurance experts. Programmers have the most experience and, therefore, can identify areas that may be vulnerable since they are aware of how the program works. On the other hand, end-users can focus their attention on routine tasks, ensuring the software fulfills its requirements. Lastly, quality assurance experts can examine the software from different perspectives such as architecture, security, integration with other systems, etc. Therefore, these different testing levels mean that a number of different test plans should be drawn for the software testers during the test stage.

 

Stage five

 

Deployment

 

This is a stage where the developer engages in verification of all the test cases run to ensure the successful execution of a software, correctness, and comprehensive. At this stage, the developer can secede on the way forward, depending on whether the software runs or not. This further helps determine if the software can be deployed to the production unit, and thus this stage is necessary. The deployment plan is needed to facilitate the approvals and the changes date to be effective. The guideline documentation should also be prepared, for instance, the installation guide and the user guide. The support team members should also be ready to table the questions from the users. In conclusion, the contingency plans should be developed in accordance with the successfully deployed software. After implementing the software, the common solutions are posing the software to re-launch, redo, and retest.

 

The need for software development life cycle

Normally there is a huge temptation for developers to launch and run the software without planning or designing, especially when it comes to small to medium-sized projects. The programmers tend to argue that time is wasted when on the use of planning. This is a misconception in that planning is good for the programmers to come up with. Management also tends to focus on efficiency and ensure they use the least amount of the resources to get the same result. However, there is a certain reason behind the need for the software development life cycle. The following are some of the advantages.

 SDLC need for Quality Assurance and Quality Control

The definition of quality assurance can be termed as the set of activities that ensure the software’s quality is met by controlling the activities. It prevents defects by ensuring focus on the process of software development. It aims at identifying the defects by examining the finished products. The actual main goal of quality assurance involves eliminating defects and bugs to improve quality control. These set procedures ensure the product developed delivered up to the high set standard without the shortcoming or unreasonable issues.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

CHAPTER THREE

 

In this research, the hybrid of qualitative and quantitative methods will gather information necessary to answer the research question. The research question will be to determine the strategies adopted in the software development life cycle. The research will extensively examine the models of software development life cycles known or documented to have been used in software development developing applications. The software development life cycle must is adopted by most of the developers and industries developing software. It aids in gathering the necessary information to ensure the success of software development. The documented models and processes will generate data for this research to define the accurate stages pertaining to application development steps, their components, and their recommendation. The above information will aid the researcher in examining useful gaps. That will help the app developers develop applications that use effective technology to improve the software’s quality.

Data preparation and analysis

Data preparation will be done through a process stipulated by Trochim (2006a). The data will be analyzed based on the findings presented in tables, graphs, and charts. Moreover, data obtained will be captured and grouped into qualitative data, which will help derive conclusions and recommendations. Quantitative data will be collected, including the analytics and how frequently the organization uses SDLC and presented graphs and pie charts.

According to Trochim (2006), standard protocols must be followed when dealing with web-based social research. The methods and protocols proposed in his findings will be used in this research since the research falls under the social research category. In these protocols, data preparation will be done following the guidelines and steps to create a necessary framework that aids the data analysis. Considering the research objectives, some of the steps stipulated will be modified to allow the researcher to come up with the necessary data for the research objective. This will prevent the collection and analysis of unnecessary data, which can cause data biasness. Considering the preparation processes of Trochim (2006), the researcher will follow the guidelines below during data preparation.

Therefore, the research will undertake the necessary steps required for the software development life cycle process. Several models of the SDLC have been identified, and each model tends to follow a series of certain unique steps to fit the project type under development. These models to be discussed include waterfall iterative agile scum and Rapid Application Development.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

CHAPTER FOUR

RESULTS

Data Analysis

The articles used in this research, two were published in the year 2014. The other one is 2012 and the other in 2015. The publications and the SDLC guide were used in this research. The studies showed multiple utilization and outcome of SDLC software development. From all the publications, SDLC models were shown to have widely spread in various organizations. The development industries cited in the articles had reported that 60% of their software development is done by using the SDLC standard guidelines. 40% of programmers were shown to not following the SDLC guidelines fully.

Concerning methods of Software Development life cycle, 57% of organizations listed in the articles adopted the waterfall model, 23% were listed to have used the iterative, whereas 20% were indicated that they use to match up and multiple models in developing their software’s.

FINDINGS

4.1 Phases of SDLC Models

Waterfall model

This oldest best known-model commonly adopted methodology. It is a sequential life cycle known to be simple in its implementation, usage, and adoption. Each phase in this model needs to be completed so as to successfully ensure the software standard successfully.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	Figure 2- waterfall model

 

 

 

Requirement

 

 

 

Design

 

 

 

Implementation

 

 

 

Testing

 

 

 

Deployment

 

 

 

Mainten                 ance

 

 

 

 

 

 

 

 

This model involves the following phases

1. Requirement

This phase tends to focus on communication with the business and users to collect and analyze the requirements. Here the manager should capture all the user’s needs, define the scope, and arrange the resources needed.

1. Design

The software engineer evaluates and begins the software’s logical design at this phase by utilizing the information and the requirement selected at the requirement phase. Depending on the high-level design which has met all the user requirements, the system analysts transform the design into the physical design by considering the software and hardware/ it also entails the system architecture at this phase.

1. Implementation

This is a phase where the actual software code is written. This stage entails the programmers coming together to develop the software according to the instructions captured earlier on. This phase’s output is the functional specification, which covers all the details of the implemented functions.

1. Testing

With all the inputs originating from the implementation phase, testers are used in the testing phase to draft the test plan based on the specific functions. The programmers prepare the test plan to examine if all the functions in the software are functioning the way they are expected.in the final stage of this phase, the quality control experts are engaged in documenting from all the previous phases and do the overall test and the technology they use

1. Deployment and maintenance

After the success pass from the testing phase, the developers can engage in the product’s release steps. At this phase, the software can be deployed. Software deployment can be deployed to the production server or release the software to users for their computers.

1. Maintenance

In reality, issues are inevitable, and thus, at this phase, necessary adjustments and changes are made simultaneously since the world keeps changing every day. As a result, enhancement tends to be necessary from time to time. This phase, therefore, is for gathering such situations.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Figure 3–In p u t s a n d O u tp u t s pictorial summary.

 

1. Requirement

 

• Business Case Documentation

 

 

2. Design

 

• Software Requirement Specification

 

• Design Documentation Specification

 

 

3. Implementation

 

• Functional Specification

 

 

 

4. Testing

 

• Test Plans

 

 

5. Deployment

 

• Deployment Plan

 

• Contingency Plan

 

 

 

The waterfall model is applied in the software development life cycle when there is limited demount or unconfirmed requirements. Software development that needs documentation tends to use technologies and not dynamics. Through the use of the resources, the management can adopt the resources and experts take over the role of the teaching phase.

Iterative

The iterative model works best of simplified requirements, which are known as the software subsets. It makes the product under development iteratively enhanced. It is called build and designed to enable the functionalities to be added to the product. With this model, developed software can be tested or previewed in a small portion at a time.

 

 

 

 

 

 

 

Figure 4- iterative model

 

R e q u i r e m e n t s

 

 

 

 

Design	Design
Implement	Implement
Test	Test
Design
Implement
Test
Design	Design
Implement	Implement
Test	Test

 

 

Deployment

 

 

Maintenance

 

 

 

 

 

 

 

 

 

 

 

Phases of Iterative Model

1. Requirement phase

This is the phase that is the same as that of the waterfall model.

1. Design phase

Like the waterfall, it entails logical and physical design based on the software development requirements. The subset of the design can be modified with an interval of every build, and thus the subset of design cannot be marked complete until the deployment stage is reached.

• Implementation stage

Involves the programmer’s actual coding of the software basing on the instructions set at fazes one. Here the specification is also prepared for every subset of the implementation.

1. Testing

This set resembles that of a waterfall. It focuses on ensuring quality control and assurance.

1. Deployment

This stage has no variation from that of the waterfall. Here everything should be read by this phase and the deployment plan done.

4.2 Pros and Cons Associated With SDLC Methodologies

Advantages of waterfall

Waterfall technique comes with some of the advantages, which include the fact that it is easier to manage since there is a clear schedule for every stage, it tends as well the be easier to control with the limited external factors which can overlap the developmental stages, it further provides distinct actions and thus allowing the project to go on uninterrupted.

Disadvantages associated with waterfall

• It does not have the requirement change.
• It does not allow a preview of the developed product until the deployment phase.
• The model requires more resources.
• It is a poor model to adopt when undertaking long or ongoing software development projects.

ADVANTAGES OF ITERATIVE METHODOLOGIES

Advantages

• Easier to start and good for complex projects
• It allows parallel implementation.
• It offers easier testing and troubleshooting as well as it is less costly as compared to other methodologies.

D Is a d v a n t a g e s

 

• It is highly risky, especially to system architecture and the design, which keeps changing.
• Issues might arise, especially when integration or build is done.
• Overlapping the implementation may turn chaotic.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

CONCLUSION

 

In conclusion, the software development life e cycle has evolved from different models to meet the huge demand for software development and expectations. There is no suitable model for all the projects starting from the conditions up to payment models. The most common technique involves multi-purpose agile. However, it does not only be used widely due to the fact that some of the developers are unprepared to scale up their technique. It is also affected by developers’ preference to select the most efficient software development life cycle model. The software development life cycle often crosses one another in the sense of solution and particularly looks similar in the actions.

The main reason behind the Software Development Life Cycle (SDLC) is building the software that ensures software development’s software quality and correctness. SDLC in software engineering gives the framework for a given standard set of activities and deliverables. Stages of the SDLC, in general, include requirement collection and analysis, the feasibility study design coding testing deployment, and maintenance.