Basics of Software Testing - Part-IV : Software Development Life Cycle (SDLC)

A little background about this - Each person may have their own way of testing or finding issues. They may not necessarily find my method helpful to understand the basics, this is something i'm trying to generalize for the newcomers in software/ firmware testing.  My intention is to make a series out of it, if i can and get enough motivation to write the basic stuffs.

It is really hard to summarize the 4 year course, i’m just touching some topics which may give you an overall idea about the software. Details can be found on Google/ Wiki as well, if interested.

Basics continues…… previous topic

Software Development Life Cycle (SDLC):

To my understanding it’s about - How the software is developed (Process), what method used to develop the software is the Software Development Life Cycle. Before we want to start the software testing it is more important to understand the development life cycle. Not in details but at least have an understanding of how things are done. Once we understand how it works, we then can design how to attack (Testing) it. Again, there is wiki for all these terminologies. feel free to explore the details…

Different Methodologies:

There are different methodologies followed in SDLC, some mentionable/ commonly used are as follows:

1. Waterfall
2. Iterative/ Incremental Development
3. Sprial
4. Prototyping
5. Agile
6. Rational Unified Process (RUP)

Picture Source (wiki): "Three software development patterns mashed together" by Beao | waterfall by Paul Smith

I would like to emphasise the Waterfall method as this gives a visual representation of the whole process and since all other methods are basically a modified improved version of this method.

Waterfall method:

Basically a sequential development approach that allows to finish one step at a time and then start the other process. The water falls from one stage to another.  From the above picture you can see it has several phases:

1. Requirement Analysis - The first thing of the development is to set the Requirements/ Objectives for the software. This allows to get an idea about the software giving us the in the form of a document called  “Specifications” (Specs) which is THE key document for testing.

2. Design- Then comes the Design.  Once we know what to build from the Specs, we need to design the architecture, framework, platform, tools of the software to build. According to this methodology this phase is the most important and time consuming. Roughly about 60% of the whole process used to be used here.  

3. Implementation - Once the design is done, then the Coding starts. It should be just lines of code following the instructions of the Design phase.

4. Verification -  Testing begins after the Code is freezed. Once we have a build, we start testing. Build means a stage of a workable program. It will consist with different types of testing starting from Black box testing to End to End testing. Software is developed in phases or pieces. So at the end we will have to integrate all the component and test it as a whole software. Then once the software is tested, it needs to be deployed to the actual sites.

5. Maintenance-  It is about the maintenance of the software.

As you can see from the above description, one stage start when previous stage finishes. Now in the real world, it is very rare that this will happen like this. And this is not an optimum use of time and resources.  So people around the world, develop more and more modified version of this traditional approach as mentioned in previous section.  

Iterative:

One of the recent popular method says, instead of getting something at the end of development phase, it makes the steps into many pieces. It goes to deeper level, tells us to identify a functionality/ set of functionality and test it as it develops. This approach basically reduces the big phase of Testing which waterfall wanted to start once the development is done. When you test every pieces, at the end, you can expect the software will be pretty much covered with testing.    

Agile:

"In Agile, People and interactions are emphasized, rather than processes and tools. Customers, developers, and testers constantly interact with each other. This interaction ensures that the tester is aware of the requirements for the features being developed during a particular iteration and can easily identify any discrepancy between the system and the requirements." 

Agile basically in favor of engaging testing in all phases (if I interpret it correctly). There is an advantage of Agile method- customer is a part of team. So, the gap between the developer and customer being reduced here. Customer does not always be there and does not necessarily understand all technical thing of the software. So, testing team still can be a bridge between developer and customer. Testing team also gets the advantage of knowing the user, user's requirement,  expectation and importantly, user's psychology

Just for the information, I have a separate relevant blog topic written on the topic about when we should engage testing. link.

Lastly, no matter which method, whoever follows, all we need to have is an understanding of the process and the SPECs document from a Tester point of view.

Next Topic, Software Testing Life Cycle (STLC)