SE

 

SDLC Models in Detail:

1. Waterfall Model:

- This is the basic/classic SDLC model

- The phases happen in a strict linear sequence - requirements, design, implementation, testing, deployment, maintenance

- Each phase must be completed fully before moving to the next phase

- It is like a "waterfall" of progress flowing steadily downwards

- Easy to understand and use, but very rigid and no room for revisions once a phase is over

2. Iterative Waterfall Model: 

- Provides a feedback path to previous phases to allow changes/revisions

- For example, if an issue is found in testing, you can loop back and rework the design

- More flexible than the basic waterfall, but still quite rigid and sequential

3. Incremental Model:

- The product is built and delivered in incremental releases

- For example, an email app may release basic emailing first, then add calendaring, contacts, etc. in later increments  

- Each increment goes through the full SDLC cycles

- Allows faster delivery of core functionality to users

- Users can use and evaluate the early increments

4. Prototyping Model:

- A basic working prototype is built quickly with minimal requirements

- The prototype is reviewed and reworked based on feedback until an acceptable final system is achieved

- Useful when requirements are unclear or likely to change

- Allows user evaluation and feedback from the beginning

5. RAD (Rapid Application Development) Model:

- Uses powerful tools/technologies to build software extremely quickly in 60-90 day "timeboxes"

- Focuses on reusable components and accommodating changing requirements  

- Suitable for projects with modular components and skilled, experienced teams

6. Spiral Model: 

- Combines prototyping and incremental approaches

- Works in multiple spiral cycles of planning, risk analysis, engineering, and evaluation

- The "spiral" represents progressively more complete versions of the software 

- Focused heavily on risk analysis and resolution

7. Agile Models:

- Iterative and incremental approaches are core principles 

- Uses short sprints/iterations to frequently release working increments

- Emphasizes customer involvement, responding to change over rigid plans

- Examples are Scrum, XP, Lean, Crystal

SDLC Stages in Detail:

1. Planning and Requirement Analysis

- Understanding why the software is needed, what it should do, for whom 

- Conducting a feasibility study on whether it can actually be done

2. Defining Requirements

- Taking the high-level requirements and detailing them out fully

- Creating clear, comprehensive documentation like the Software Requirements Specification (SRS)

3. Design and Prototyping

- Deciding on the architecture, components, interfaces of the system

- Building a prototype based on core requirements for evaluation

4. Implementation/Coding 

- The actual programming and production of the working software

- Following coding standards and practices

5. Testing

- Running the developed software through various tests 

- Like unit tests, integration tests, system tests, acceptance tests

6. Deployment

- Delivering the final working software into the production environment for use

7. Maintenance  

- Fixing issues, enhancing features, adapting to changes after deployment

Software Crisis Explanation:

In the 1960s-70s, many software projects started failing due to issues like:

- Going over-budget and missing deadlines 

- Delivered software was unreliable, low-quality and hard to maintain

- Growing gap between software's complexity and developers' ability to build it

The root causes included:

- Inaccurate time/cost estimation upfront

- Lack of proper processes and engineering principles

- Rapidly changing/unclear requirements

- Lack of documentation and communication

- Increasing technical complexity beyond skills

The proposed solution was:

- Treat software development as an engineering discipline 

- Adopt defined processes, specifications, validation and evolution practices

- Use layered models like Waterfall to structure and control development

This aimed to transform the ad-hoc coding efforts into an organized, controlled process.

Software Characteristics Explained:

1) Functionality, Reliability, Efficiency, Usability, Maintainability, Portability

- These are key quality attributes software must possess

2) Software is engineered, not manufactured

- Software is developed and grown over time, unlike physical goods being manufactured

3) Software doesn't "wear out" physically like hardware

- No environmental impacts that degrade hardware 

- But software can deteriorate as requirements change over time

4) Most software is custom-built vs reusable 

- Though software reuse is increasing, most is still custom developed for specific needs

5) Software is flexible but not replaceable

- Features can be changed easily compared to hardwares

- But no "spare parts" - any issues require reworking the software itself

Let me know if any part needs any further explanation!