Monitoring and Control Coding

1️.  Introduction to Monitoring and Control in Coding

Monitoring and Control Coding refers to the systematic supervision and management of the coding phase in software development to ensure that implementation follows the approved design, standards, schedule, and quality requirements.

Coding is not just writing programs. It must be:

• Controlled
• Measured
• Reviewed
• Improved continuously

Without monitoring, coding may lead to:

• Poor quality
• Delays
• Security vulnerabilities
• Maintenance difficulties

Thus, monitoring and control ensure disciplined software implementation.

2️. Objectives of Monitoring and Control in Coding

The primary objectives are:

🔹 Ensure Code Quality

Code must be reliable, readable, maintainable, and efficient.

🔹 Maintain Design Consistency

Implementation must strictly follow design specifications.

🔹 Detect Errors Early

Bugs should be identified during coding, not after deployment.

🔹 Maintain Project Schedule

Coding progress should align with deadlines.

🔹 Ensure Standard Compliance

Code must follow coding standards and organizational policies.

3️. Importance of Monitoring During Coding

Monitoring is important because:

• Large projects involve multiple developers.
• Coding inconsistencies create integration issues.
• Poor code increases maintenance cost.
• Security vulnerabilities may arise from careless coding.

Continuous supervision ensures smooth project execution.

4️. Coding Standards

Coding standards are guidelines that define how code should be written.

They include:

🔹 Naming Conventions

Variables, functions, and classes should follow consistent naming rules.

Example:

• camelCase (studentName)
• PascalCase (StudentRecord)

🔹 Indentation and Formatting

Proper spacing improves readability.

🔹 Commenting Guidelines

Comments should explain logic clearly but avoid unnecessary statements.

🔹 File Structure Organization

Code files should be modular and logically arranged.

Following coding standards improves:

• Maintainability
• Team collaboration
• Debugging efficiency

5️. Code Reviews

Code review is a systematic examination of source code by peers.

It helps to:

• Detect logical errors
• Improve performance
• Ensure design compliance
• Identify security vulnerabilities

Types of code reviews:

• Peer Review
• Pair Programming
• Formal Inspection

Code reviews reduce defect density significantly.

6️. Version Control and Configuration Management

Version control tools such as:

• Git
• SVN
• Mercurial

Help in:

• Tracking changes
• Managing multiple developers
• Maintaining code history
• Handling rollbacks

Configuration management ensures:

• Controlled modification
• Proper version labeling
• Release management

It prevents accidental overwriting of code.

7️. Code Metrics for Monitoring

Code metrics are quantitative measures used to evaluate code quality.

Common metrics include:

🔹 Lines of Code (LOC)

Measures size of software.

🔹 Cyclomatic Complexity

Measures complexity of logic.

Higher complexity means more difficult testing and maintenance.

🔹 Code Coverage

Measures percentage of code tested.

🔹 Defect Density

Number of defects per module.

Metrics help managers track coding progress objectively.

8️. Static and Dynamic Code Analysis

🔹 Static Analysis

Code is analyzed without executing it.

Tools detect:

• Syntax errors
• Security flaws
• Code smells
• Unused variables

🔹 Dynamic Analysis

Code is tested during execution.

It identifies:

• Runtime errors
• Memory leaks
• Performance bottlenecks

Both are essential for effective monitoring.

9️. Debugging and Error Control

Debugging is the process of identifying and fixing defects.

Steps include:

1. Identify error
2. Locate source
3. Correct defect
4. Re-test system

Error control techniques:

• Exception handling
• Input validation
• Logging mechanisms
• Defensive programming

Proper debugging improves system stability.

10. Risk Monitoring in Coding Phase

Risks during coding include:

• Developer dependency
• Skill gaps
• Integration conflicts
• Technology issues

Project managers monitor:

• Coding progress reports
• Bug reports
• Performance benchmarks

Risk control ensures smooth development.

1️1️. Documentation During Coding

Documentation is part of control.

Includes:

• Inline comments
• API documentation
• Technical documentation
• Change logs

Good documentation helps future maintenance.

1️2. Continuous Integration (CI)

Continuous Integration means:

• Code is integrated frequently.
• Automated tests are run automatically.

Benefits:

• Early detection of integration issues
• Faster feedback
• Improved quality

CI tools include:

• Jenkins
• GitHub Actions
• GitLab CI

1️3️. Best Practices for Controlled Coding

• Write modular code
• Keep functions small
• Avoid code duplication
• Follow Single Responsibility Principle
• Test regularly
• Refactor when necessary

These practices maintain code quality.

1️4️. Role of Monitoring and Control in SDLC

Monitoring ensures:

Design → Implementation → Testing → Deployment

happens smoothly and without quality compromise.

It acts as a bridge between design verification and testing.

📌 Conclusion

Monitoring and Control Coding is a critical activity that ensures disciplined, high-quality software implementation. It involves applying coding standards, performing code reviews, using version control, measuring code metrics, and continuously evaluating risks.

Through systematic monitoring and control, software organizations can reduce defects, improve maintainability, ensure timely delivery, and produce reliable software systems.

 

 

Design Verification

1️⃣ Introduction to Design Verification

Design Verification is the process of evaluating software design to ensure that it correctly implements the requirements specified in the Software Requirement Specification (SRS).

It answers the question:

“Are we designing the system correctly according to the requirements?”

Design verification is performed before implementation to detect errors early, reduce cost, and improve quality.

Errors found during design stage are much cheaper to fix compared to coding or maintenance stage.

2️⃣ Objectives of Design Verification

The main objectives are:

🔹 Ensure Requirement Compliance

The design must completely and correctly reflect all requirements mentioned in SRS.

🔹 Detect Design Errors Early

Logical mistakes, incomplete modules, missing interfaces, and inconsistencies are identified early.

🔹 Improve Quality

Verification improves reliability, maintainability, and performance.

🔹 Reduce Development Cost

Fixing errors in design stage is far cheaper than fixing after deployment.

3️⃣ Need for Design Verification

Design verification is necessary because:

• Complex systems may have hidden logical flaws.
• Missing modules may not be noticed during coding.
• Interface mismatches can cause integration failures.
• Poor design decisions affect long-term maintenance.

Without verification, a system may satisfy coding standards but fail to meet business requirements.

4️⃣ Design Verification vs Design Validation

These two terms are often confused.

Design Verification	Design Validation
Checks correctness of design	Checks usefulness of system
“Are we building the product right?”	“Are we building the right product?”
Done during development	Done after development

Verification ensures design correctness.
Validation ensures customer satisfaction.

5️⃣ Techniques of Design Verification

There are several systematic methods used to verify software design:

5.1 Design Reviews

Design review is a formal evaluation process where experts examine design documents.

Types of reviews:

• Informal Review
• Peer Review
• Technical Review
• Formal Inspection

During review, team members check:

• Completeness
• Consistency
• Logical correctness
• Interface design
• Standard compliance

Reviews are one of the most effective verification methods.

5.2 Walkthroughs

In walkthrough, the designer explains the design step-by-step to the team.

Team members ask questions and identify:

• Logical gaps
• Missing cases
• Performance concerns

Walkthroughs encourage collaboration and knowledge sharing.

5.3 Prototyping

A small working model is created to verify design assumptions.

It helps in:

• Validating user interface
• Checking workflow
• Confirming functionality

Prototyping reduces ambiguity in requirements.

5.4 Simulation

Simulation tests the system design using models without full implementation.

It helps evaluate:

• Performance
• Scalability
• Resource utilization

Simulation is useful for real-time and embedded systems.

5.5 Formal Verification

Formal verification uses mathematical methods to prove correctness.

It ensures:

• Logical consistency
• Error-free algorithms
• Compliance with specifications

It is mostly used in safety-critical systems such as aviation and medical software.

6️⃣ Design Verification Process

The general steps involved are:

1. Review SRS document
2. Compare design with requirements
3. Check module interfaces
4. Verify data structures
5. Evaluate performance considerations
6. Document defects
7. Correct and re-evaluate

This systematic approach ensures structured verification.

7️⃣ Attributes Checked During Design Verification

The following characteristics are evaluated:

🔹 Completeness

All requirements must be covered.

🔹 Consistency

No contradictory logic.

🔹 Traceability

Every design element must map to a requirement.

🔹 Modularity

Proper separation of modules.

🔹 Maintainability

Design should allow future changes.

🔹 Efficiency

Design should optimize time and memory usage.

8️⃣ Benefits of Design Verification

• Improves reliability
• Reduces project risk
• Enhances documentation quality
• Prevents system failure
• Saves development time
• Increases customer satisfaction

9️⃣ Challenges in Design Verification

• Requires experienced reviewers
• Time-consuming process
• May delay development schedule
• Overlooking minor issues

Despite challenges, verification is essential for quality assurance.

🔟 Role of Design Verification in SDLC

In SDLC, design verification acts as a quality gate between:

Requirement Phase → Design Phase → Implementation Phase

Only after verification approval should the system move to coding phase.

This ensures strong foundation for software construction.

📌 Conclusion

Design Verification is a critical activity in software development that ensures the software design correctly represents the specified requirements. It helps identify errors early, reduces cost, improves reliability, and enhances system quality.

By applying techniques such as reviews, walkthroughs, prototyping, and formal verification, software engineers ensure that the system design is complete, consistent, and correct before implementation begins.

 

 

Design Methodology

(Structured Design and Object-Oriented Design)

 

 Introduction to Design Methodology

Design methodology refers to the systematic approach used to create the structure and organization of a software system. It defines how design activities are carried out and how system components are organized.

After understanding design fundamentals, the next step is deciding how to design. This is where design methodologies come into play.

There are two major design methodologies:

1. Structured Design
2. Object-Oriented Design (OOD)

Each methodology has its own principles, techniques, advantages, and suitable application areas.

2️. Structured Design

2.1 Introduction to Structured Design

Structured Design is a traditional software design methodology that focuses on functions and processes. It is derived from structured analysis and is mainly used in procedural programming.

The main objective of structured design is to divide the system into smaller functional modules using a top-down approach.

In this approach, the system is decomposed step-by-step into smaller and manageable modules.

2.2 Key Concepts of Structured Design

🔹 Top-Down Decomposition

The system is first viewed as a whole and then broken down into smaller sub-systems and modules. Each module performs a specific function.

This makes the system easier to understand and implement.

🔹 Functional Decomposition

The entire system is divided into smaller functional units. Each function is clearly defined and implemented separately.

This helps reduce complexity and improves maintainability.

🔹 Structure Charts

Structure charts are graphical tools used in structured design. They show:

• Module hierarchy
• Module interactions
• Data flow between modules

Structure charts help visualize the system structure clearly.

🔹 Cohesion and Coupling

Structured design emphasizes:

• High cohesion (modules perform single task)
• Low coupling (minimal interdependence between modules)

These principles improve system quality.

2.3 Advantages of Structured Design

• Easy to understand
• Suitable for small and medium projects
• Clear modular representation
• Works well with procedural languages like C

2.4 Limitations of Structured Design

• Not suitable for very large systems
• Difficult to handle changing requirements
• Focuses more on functions than real-world entities
• Limited reusability

3. Object-Oriented Design (OOD)

3.1 Introduction to Object-Oriented Design

Object-Oriented Design is a modern design methodology that focuses on objects instead of functions.

An object represents a real-world entity and contains:

• Attributes (data)
• Methods (behavior)

OOD is based on Object-Oriented Programming principles such as:

• Encapsulation
• Inheritance
• Polymorphism
• Abstraction

It is widely used in modern software development.

3.2 Key Concepts of Object-Oriented Design

🔹 Objects and Classes

A class is a blueprint, and objects are instances of that class.

For example:
Class: Student
Object: Rahul (instance of Student)

This makes modeling real-world systems easier.

🔹 Encapsulation

Encapsulation binds data and methods together and hides internal details from outside access.

It increases security and reduces system dependency.

🔹 Inheritance

Inheritance allows one class to acquire properties of another class.

This supports reusability and reduces redundancy.

🔹 Polymorphism

Polymorphism allows objects to behave differently under different conditions.

It improves flexibility and scalability.

🔹 UML Diagrams

Object-Oriented Design commonly uses UML diagrams such as:

• Class diagrams
• Sequence diagrams
• Use case diagrams
• Activity diagrams

These diagrams visually represent system structure and behavior.

3.3 Advantages of Object-Oriented Design

• High reusability
• Better scalability
• Easy maintenance
• Real-world modeling
• Suitable for complex systems

3.4 Limitations of Object-Oriented Design

• Requires understanding of OOP concepts
• More complex than structured design
• Initial design may take more time

4️⃣ Comparison: Structured Design vs Object-Oriented Design

Aspect	Structured Design	Object-Oriented Design
Focus	Functions	Objects
Approach	Top-down	Bottom-up
Programming Style	Procedural	Object-Oriented
Reusability	Low	High
Maintenance	Difficult	Easier
Suitable For	Small systems	Large & complex systems

5️⃣ When to Use Which Methodology?

Structured Design is suitable when:

• Requirements are stable
• System is small
• Procedural programming is used

Object-Oriented Design is suitable when:

• System is complex
• Long-term maintenance is required
• Reusability is important
• OOP languages are used

📌 Conclusion

Design methodology defines how software structure is created. Structured Design focuses on functional decomposition using a top-down approach, while Object-Oriented Design focuses on modeling real-world objects using classes and inheritance.

In modern software development, Object-Oriented Design is widely preferred because of its flexibility, reusability, and scalability. However, structured design remains useful for smaller procedural systems.

Understanding both methodologies enables software engineers to choose the appropriate design approach based on project requirements.

 

 

Software Design Fundamentals

1. Introduction to Software Design

Software Design is one of the most important phases in the Software Development Life Cycle (SDLC). After gathering and documenting requirements in the SRS, the next step is to transform those requirements into a structured technical solution. This transformation is known as software design.

Software design acts as a bridge between requirement analysis and coding. While requirements describe what the system should do, design explains how the system will achieve those requirements.

Without proper design, development becomes unorganized, complex, and error-prone. A well-prepared design ensures that coding becomes systematic, efficient, and maintainable.

2. Definition of Software Design

Software design can be defined as a systematic process of creating a blueprint for constructing software. It involves identifying system architecture, components, interfaces, and data structures.

It provides a detailed plan for implementation and helps developers understand the structure and behavior of the system before actual coding begins.

The output of the design phase is usually documented in a Software Design Document (SDD), which serves as a reference throughout development and maintenance.

3. Objectives of Software Design

The main objective of software design is to convert user requirements into a technical solution. It ensures that the system architecture is properly defined before coding begins.

Another objective is to reduce development risks by identifying potential problems early. Design also aims to improve software quality by ensuring modularity, maintainability, and efficiency.

Proper design makes debugging easier, enhances communication among team members, and reduces overall development cost.

4. Importance of Software Design

Software design plays a crucial role in the success of a software project. A good design:

• Reduces coding complexity
• Minimizes future maintenance effort
• Improves system performance
• Enhances scalability

Poor design often leads to software failure, increased maintenance cost, and difficulty in upgrading the system. Therefore, investing time in design significantly improves the overall quality and reliability of the software.

5. Characteristics of Good Software Design

A good software design should satisfy certain essential qualities.

Correctness

The design must correctly reflect all the requirements specified in the SRS document. If the design does not match requirements, the final product will fail to meet user expectations.

Simplicity

A design should be simple and easy to understand. Complex designs increase the risk of errors and make maintenance difficult.

Efficiency

The design should ensure optimal use of resources such as memory, processing time, and storage.

Maintainability

Software should be easy to modify and update when requirements change. Good design supports future enhancements.

Reusability

Design components should be reusable in other projects. Reusability saves time and development effort.

Reliability

The design must ensure that the system performs consistently under defined conditions.

Modularity

The system should be divided into smaller modules so that each module performs a specific function independently.

6. Fundamental Concepts in Software Design

Software design is based on several important principles.

6.1 Abstraction

Abstraction is the process of hiding unnecessary implementation details and showing only essential features. It helps manage complexity by focusing on high-level concepts rather than low-level details.

For example, when using a mobile phone, we interact with icons and buttons without worrying about internal circuits. Similarly, in software design, abstraction allows designers to focus on what a module does rather than how it does it.

Abstraction improves clarity and reduces design complexity.

6.2 Modularity

Modularity means dividing a software system into smaller independent modules. Each module performs a specific function and can be developed, tested, and maintained separately.

Modular design improves flexibility, reduces errors, and enhances system maintainability. If one module fails, other modules remain unaffected.

6.3 Encapsulation

Encapsulation refers to combining data and the functions that operate on that data into a single unit. This is commonly implemented using classes in object-oriented design.

Encapsulation protects data from unauthorized access and prevents accidental modification. It improves security and system stability.

6.4 Information Hiding

Information hiding ensures that the internal implementation details of a module are not exposed to other modules. Only necessary interfaces are provided.

This reduces dependency between modules and improves system maintainability.

6.5 Cohesion

Cohesion measures how closely related the functions within a module are. A module with high cohesion performs a single well-defined task.

High cohesion is desirable because it improves clarity, maintainability, and reliability.

6.6 Coupling

Coupling measures the level of interdependence between modules. Low coupling is desirable because it allows modules to function independently.

Low coupling reduces the impact of changes in one module on others and improves flexibility.

7. Levels of Software Design

Software design is generally divided into two main levels.

7.1 High-Level Design (HLD)

High-Level Design focuses on system architecture. It identifies major components, modules, and their interactions.

HLD provides a big-picture view of the system and defines overall system structure.

7.2 Low-Level Design (LLD)

Low-Level Design focuses on detailed internal logic. It specifies algorithms, data structures, and detailed module specifications.

LLD acts as a direct guide for programmers during coding.

8. Software Design Activities

The design phase includes several activities:

• Architectural design
• Data design
• Interface design
• Component-level design

Each activity ensures that different aspects of the system are properly structured.

9. Role of Software Design in SDLC

Software design is positioned between requirement analysis and implementation in SDLC. It ensures that coding is systematic and organized.

Without proper design, developers may implement inconsistent logic, leading to integration problems and increased defects.

10. Challenges in Software Design

Designing software is challenging due to:

• Changing requirements
• Time constraints
• Complex systems
• Integration with existing systems
• Technology limitations

Handling these challenges requires strong analytical skills and experience.

Conclusion

Software Design Fundamentals form the backbone of software engineering. They ensure that requirements are transformed into a structured, efficient, and maintainable solution. Concepts such as abstraction, modularity, cohesion, and coupling help reduce complexity and improve system quality.

A well-designed software system is easier to implement, test, maintain, and enhance. Therefore, understanding software design fundamentals is essential before studying advanced topics like structured design and object-oriented design.

 

http://

 

Evolutionary Model

 

The evolutionary model is a combination of the Iterative and Incremental models of the software development life cycle. Delivering your system in a big bang release, delivering it in incremental process over time is the action done in this model. Some initial requirements and architecture envisioning need to be done. It is better for software products that have their feature sets redefined during development because of user feedback and other factors. This article focuses on discussing the Evolutionary Model in detail.

What is the Evolutionary Model?

The Evolutionary development model divides the development cycle into smaller, incremental waterfall models in which users can get access to the product at the end of each cycle.

1. Feedback is provided by the users on the product for the planning stage of the next cycle and the development team responds, often by changing the product, plan, or process.

2. Therefore, the software product evolves with time.

3. All the models have the disadvantage that the duration of time from the start of the project to the delivery time of a solution is very high.

4. The evolutionary model solves this problem with a different approach. 

5. The evolutionary model suggests breaking down work into smaller chunks, prioritizing them, and then delivering those chunks to the customer one by one.

6. The number of chunks is huge and is the number of deliveries made to the customer.

7. The main advantage is that the customer’s confidence increases as he constantly gets quantifiable goods or services from the beginning of the project to verify and validate his requirements.

8. The model allows for changing requirements as well as all work is broken down into maintainable work chunks. 

Application of Evolutionary Model

1. It is used in large projects where you can easily find modules for incremental implementation. Evolutionary model is commonly used when the customer wants to start using the core features instead of waiting for the full software.

2. Evolutionary model is also used in object oriented software development because the system can be easily portioned into units in terms of objects.

Necessary Conditions for Implementing this Model

1. Customer needs are clear and been explained in deep to the developer team.

2. There might be small changes required in separate parts but not a major change.

3. As it requires time, so there must be some time left for the market constraints.

4. Risk is high and continuous targets to achieve and report to customer repeatedly.

5. It is used when working on a technology is new and requires time to learn.
   
   

Evolutionary Model

 

Advantages Evolutionary Model

1. Adaptability to Changing Requirements: Evolutionary models work effectively in projects when the requirements are ambiguous or change often. They support adjustments and flexibility along the course of development.

2. Early and Gradual Distribution: Functional components or prototypes can be delivered early thanks to incremental development. Faster user satisfaction and feedback may result from this.

3. User Commentary and Involvement: Evolutionary models place a strong emphasis on ongoing user input and participation. This guarantees that the software offered closely matches the needs and expectations of the user.

4. Improved Handling of Difficult Projects: Big, complex tasks can be effectively managed with the help of evolutionary models. The development process is made simpler by segmenting the project into smaller, easier-to-manage portions.

Disadvantages Evolutionary Model

1. Communication Difficulties: Evolutionary models require constant cooperation and communication. The strategy may be less effective if there are gaps in communication or if team members are spread out geographically.

2. Dependence on an Expert Group: A knowledgeable and experienced group that can quickly adjust to changes is needed for evolutionary models. Teams lacking experience may find it difficult to handle these model's dynamic nature.

3. Increasing Management Complexity: Complexity can be introduced by organizing and managing several increments or iterations, particularly in large projects. In order to guarantee integration and synchronization, good project management is needed.

4. Greater Initial Expenditure: As evolutionary models necessitate continual testing, user feedback and prototyping, they may come with a greater starting cost. This may be a problem for projects that have limited funding.

Conclusion

The evolutionary model is a helpful framework in the quickly evolving field of software development, where requirements are frequently modified and user expectations change. As with any development process, optimizing the advantages and minimizing the possible negatives of evolutionary models in software engineering requires careful evaluation of project-specific considerations.

Iterative Model

 

In the Iterative model, iterative process starts with a simple implementation of a small set of the software requirements and iteratively enhances the evolving versions until the complete system is implemented and ready to be deployed.

An iterative life cycle model does not attempt to start with a full specification of requirements. Instead, development begins by specifying and implementing just part of the software, which is then reviewed to identify further requirements. This process is then repeated, producing a new version of the software at the end of each iteration of the model.

Iterative Model - Design

Iterative process starts with a simple implementation of a subset of the software requirements and iteratively enhances the evolving versions until the full system is implemented. At each iteration, design modifications are made and new functional capabilities are added. The basic idea behind this method is to develop a system through repeated cycles (iterative) and in smaller portions at a time (incremental).

The following illustration is a representation of the Iterative and Incremental model −

Iterative and Incremental development is a combination of both iterative design or iterative method and incremental build model for development. "During software development, more than one iteration of the software development cycle may be in progress at the same time." This process may be described as an "evolutionary acquisition" or "incremental build" approach."

In this incremental model, the whole requirement is divided into various builds. During each iteration, the development module goes through the requirements, design, implementation and testing phases. Each subsequent release of the module adds function to the previous release. The process continues till the complete system is ready as per the requirement.

The key to a successful use of an iterative software development lifecycle is rigorous validation of requirements, and verification & testing of each version of the software against those requirements within each cycle of the model. As the software evolves through successive cycles, tests must be repeated and extended to verify each version of the software.

Iterative Model - Application

Like other SDLC models, Iterative and incremental development has some specific applications in the software industry. This model is most often used in the following scenarios −

• Requirements of the complete system are clearly defined and understood.
• Major requirements must be defined; however, some functionalities or requested enhancements may evolve with time.
• There is a time to the market constraint.
• A new technology is being used and is being learnt by the development team while working on the project.
• Resources with needed skill sets are not available and are planned to be used on contract basis for specific iterations.
• There are some high-risk features and goals which may change in the future.

Iterative Model - Pros and Cons

The advantage of this model is that there is a working model of the system at a very early stage of development, which makes it easier to find functional or design flaws. Finding issues at an early stage of development enables to take corrective measures in a limited budget.

The disadvantage with this SDLC model is that it is applicable only to large and bulky software development projects. This is because it is hard to break a small software system into further small serviceable increments/modules.

The advantages of the Iterative and Incremental SDLC Model are as follows −

• Some working functionality can be developed quickly and early in the life cycle.
• Results are obtained early and periodically.
• Parallel development can be planned.
• Progress can be measured.
• Less costly to change the scope/requirements.
• Testing and debugging during smaller iteration is easy.
• Risks are identified and resolved during iteration; and each iteration is an easily managed milestone.
• Easier to manage risk - High risk part is done first.
• With every increment, operational product is delivered.
• Issues, challenges and risks identified from each increment can be utilized/applied to the next increment.
• Risk analysis is better.
• It supports changing requirements.
• Initial Operating time is less.
• Better suited for large and mission-critical projects.
• During the life cycle, software is produced early which facilitates customer evaluation and feedback.

The disadvantages of the Iterative and Incremental SDLC Model are as follows −

• More resources may be required.
• Although cost of change is lesser, but it is not very suitable for changing requirements.
• More management attention is required.
• System architecture or design issues may arise because not all requirements are gathered in the beginning of the entire life cycle.
• Defining increments may require definition of the complete system.
• Not suitable for smaller projects.
• Management complexity is more.
• End of project may not be known which is a risk.
• Highly skilled resources are required for risk analysis.
• Projects progress is highly dependent upon the risk analysis phase.