What is the Software Development Life Cycle (SDLC)?
SDLC is the way an application is conceived and moved on to fruition or given a form.
Computers are faster, do not suffer from tiredness, fatigue, boredom. So any job that requires to be done repeatedly becomes a good candidate for automation. Computers are available 24 x 7, are much more economical and consistent. So all these add to considerable savings – in resources and time. So an application or program begins its life as an idea or thought. How this idea takes a form as a product, what activities are done to become a working product is what SDLC is about!
The idea is the Requirements – it answers WHAT we want the product/application to do. WHY we want the product – answers the benefits and gives an economic incentive to procure or build the product.
The Requirements are refined into the Functional Features, which address the specific requirements of the product- eg. Security, Roles and Permissions etc. Refinements happens at this level. When the feature list is complete, we have a better understanding of what we want the product to do.
Now arises the question of whether there is a ready made or Off-The Shelf product available that can do what we want. And is it cheaper than building the product from scratch?
If the answer is YES, we try the product out. If it satisfies all the needs, we don’t need to build something from scratch. Eg, Spread-sheet applications. However, if there is none or it does not satisfy all our needs or is quite expensive, we need to consider how we are going to build an new one or tweak the application we have just bought.
So, the next stage is the one where the Architect comes into picture. He tells us how we can Design the product, we can makes these building blocks (modules) and how they would lead into one other and fit together. He also decides the technical details – what coding language, database, hardware details of server etc would be the best to build the product.
The next stage is the actual building of the product – Developers take the pieces, break into still smaller, manageable pieces and start writing code or the building blocks of the application. They make sure the code does what it says it should by conducting Unit & Module Testing. After each of the different pieces are complete, they are put together and checked to ensure they fit correctly – information flows easily between the different modules. This is Integration testing.
The finished product is now handed over to an Independent Verification (System Testing) team to ensure the product does what it says it should do. Once the team has completed their checks, it is handed over to production or the Customer. The customer conducts User Acceptance Testing and accepts the product.
So Requirements lead to Functional Specifications, that leads on to Design, which leads to Coding, which leads to System testing and then User Acceptance Testing and the product is ready!
This is the Software Development process or SDLC.
This can be done as a Big Bang in a linear, sequential model – Once requirements are complete, we do design, then only coding, then only Testing. Each phase is more or less complete before the next begins. In the 80s, 90s, this was the way products were built. This is called the Waterfall model. Each stage is almost complete before the next begins. However, after a few million manhours and dollars, a few problems arose:
1. The customer missed some really important features.
2. Some features needed tweaking, they were not working like they were envisaged
3. Changes in the market and technology means the software design needs changes.
4. Since Testing activities came after the Design & Coding was more or less complete, defects were found much later and fixing the defects was proving expensive. Some bugs needs Design changes.
Making changes to millions of lines of code was proving difficult, time consuming and really expensive.
This gave rise to prototypes, incremental and iterative models of software development. The idea of build small, validate and verify, change the design, add more features along the way seemed a better way to do software development. Better for cost, design changes, defect fixes and maintenance, better for re-work. Unlike other manufacturing activities, software development is not as straight-forward activity!
In Incremental & Iterative models, a sub-set or the most important features are first designed, built, tested and a version is released. Based on customer feedback, features are tweaked, added, dropped and each Release gets bigger and better than the previous. The customer gets a chance to use the product and report changes from the very first Release. The Rational Unified Process(RUP) & Extreme Programming/Agile are examples.
In Incremental models – Design, Build, Code and Test are done for each increment. If we were writing a book, we would do a Chapter and complete it before we moved on to the next Chapter.
In Iterative models, like Agile, these stages are more loosely defined, for eg we could do Design and back to Requirements, Coding back to Design for changes etc. If were writing a book, we would just write a lot, we would review throwing out unnecessary stuff, and start again. Iterations are planned rework.
So we see, SDLC and processes are efforts to build sturdy products. And to reduce re-work and the costs.
Along the way, Validation activities were added to build better products in addition to Verification activities. Please see our Blog on Software QA vs QC for more information.