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!

Comments

Post a Comment

Popular posts from this blog

Operating System Support Easy Example

-
Image
General Explanation of OS Support Process: In computer terms, a process is like a task or a program running on your computer. The operating system manages these processes, giving each one the resources it needs (like processor time, memory, and access to devices) and making sure they don't interfere with each other. Thread: A thread is a smaller unit of a process that can execute independently. Think of it as a worker within a larger task. The operating system can manage multiple threads within a process, allowing for better multitasking and efficient use of resources. Virtual Memory: Virtual memory is a technique used by the operating system to expand the available memory beyond the physical memory (RAM) in your computer. It uses a portion of the hard disk as an extension of the RAM, allowing more programs to run simultaneously. The operating system handles the management of virtual memory, deciding which data to keep in RAM and which to store on the hard disk. File support: Op...
Read more

Cache replacement algorithm explained

-
Image
A line replacement algorithm or Cache replacement algorithm is a method for deciding which line of data to remove from a cache when it is full and a new line needs to be added. There are many different line replacement algorithms, but they all share the same basic goal: to remove the line that is least likely to be used again in the near future.  Here are the four most common line replacement algorithms explained in easy terms: FIFO FIFO stands for first-in, first-out. The FIFO algorithm removes the line that has been in the cache the longest. This is the simplest line replacement algorithm, but it is not always the most efficient. The FIFO algorithm can evict lines that are still being used, which can lead to performance problems. LRU LRU stands for least recently used. The LRU algorithm removes the line that has not been used in the longest time. This is a more efficient algorithm than FIFO, but it is also more complex. The LRU algorithm requires keeping track of when each l...
Read more

Lecture-1.1 PDC

-
### Synchronous Communication 1. **Definition**: In synchronous communication, components work in a coordinated way with a set order and timing. Here, the sender waits until the receiver confirms receipt before continuing.     2. **Characteristics**:    - **Real-Time Interaction**: The sender waits for the receiver’s reply before moving forward.    - **Request-Response Pattern**: A request is sent, and the sender pauses until a response comes back. 3. **Advantages and Disadvantages**:    - **Simplified Design**: It’s easy to design since processes are in sync, knowing exactly what’s happening when.    - **Potential Delays**: If the receiver takes time to respond, the sender is idle, which can slow down the system. 4. **Example**:     Imagine a **chat system** where every message you send has to be acknowledged by the other person immediately before you can send the next message. If the other person delays, you’re left wait...
Read more