UNIT-I

1. What are the primary phases of a typical SDLC?

The Software Development Life Cycle (SDLC) consists of several key phases, each of which
helps in organizing and structuring software development projects. The primary phases of a
typical SDLC are:
Planning
Requirements analysis
Design
Development
Testing
Deployment
Maintenance

[Link] out the primary components of a computer system.

The primary components of a computer system are:

Central Processing Unit (CPU): The computer's "brain"
Motherboard: The main circuit board that holds all the hardware in place
Random Access Memory (RAM): Keeps important data and codes on standby
Storage device: Provides memory for installing programs and saving files
Input devices: Includes a keyboard, mouse, microphone, video camera, and image scanner
Output devices: Includes a monitor, speakers, and a printer

[Link] software engineering.

Software engineering is a branch of computer science that involves the design, development,
testing, and maintenance of software applications. It's a systematic and disciplined approach to
software development that uses engineering principles and best practices to create high-quality
software.

[Link] are the main phases of Waterfall model?

Six phases of the waterfall project management methodology

Requirements phase. This is the initial planning process in which the team gathers as much
information as possible to ensure a successful project. ...
System design phase.
Implementation phase.
Testing phase.
Deployment phase.
Maintenance phase.

[Link] does iterative development enhance the Agile development process?

Iterative development significantly enhances the Agile development process by fostering

flexibility, continuous feedback, and incremental improvement. Here’s how it strengthens Agile:
Early and Frequent Delivery
Adaptability to Changing Requirements
Continuous Feedback and Improvement
Reduced Risk and Early Issue Detection

[Link] the key characteristics of the Spiral model.

The Spiral model is a software development model that has several key characteristics,
including:
Risk management:
Iterative development
Stakeholder involvement
Testing
Adaptability
Documentation control
Customer feedback
Systematic approach

Essay Questions

1. Explain water fall model in detail. (10M)

The waterfall model is useful in situations where the project requirements are well-defined and
the project goals are clear. It is often used for large-scale projects with long timelines, where
there is little room for error and the project stakeholders need to have a high level of
confidence in the outcome.
Features of Waterfall Model
1. Sequential Approach: The waterfall model involves a sequential approach to software
development, where each phase of the project is completed before moving on to the next
one.
2. Document-Driven: The waterfall model depended on documentation to ensure that the
project is well-defined and the project team is working towards a clear set of goals.
3. Quality Control: The waterfall model places a high emphasis on quality control and
testing at each phase of the project, to ensure that the final product meets the requirements
and expectations of the stakeholders.
4. Rigorous Planning: The waterfall model involves a careful planning process, where the
project scope, timelines, and deliverables are carefully defined and monitored throughout
the project lifecycle.

Importance of Waterfall Model

1. Clarity and Simplicity: The linear form of the Waterfall Model offers a simple and
unambiguous foundation for project development.
2. Clearly Defined Phases: The Waterfall Model phases each have unique inputs and outputs,
guaranteeing a planned development with obvious checkpoints.
3. Documentation: A focus on thorough documentation helps with software comprehension,
maintenance, and future growth.
4. Stability in Requirements: Suitable for projects when the requirements are clear and
stable, reducing modifications as the project progresses.
Phases of Waterfall Model
1. Requirements: The first phase involves gathering requirements from stakeholders and
analyzing them to understand the scope and objectives of the project.
2. Design: Once the requirements are understood, the design phase begins. This involves
creating a detailed design document that outlines the software architecture, user interface,
and system components.
3. Development: The Development phase include implementation involves coding the
software based on the design specifications. This phase also includes unit testing to ensure
that each component of the software is working as expected.
4. Testing: In the testing phase, the software is tested as a whole to ensure that it meets the
requirements and is free from defects.
5. Deployment: Once the software has been tested and approved, it is deployed to the
production environment.
6. Maintenance: The final phase of the Waterfall Model is maintenance, which involves
fixing any issues that arise after the software has been deployed and ensuring that it
continues to meet the requirements over time.

Waterfall Model-Software Engineering

1. Feasibility Study
The main goal of this phase is to determine whether it would be financially and technically
feasible to develop the software.
2. Requirements Analysis and Specification
 Requirement gathering and analysis. The goal of the analysis part is to remove
incompleteness and inconsistencies
 Requirement specification: These analyzed requirements are documented in a software
requirement specification (SRS) document. SRS document serves as a contract between the
development team and customers.
3. Design
The goal of this phase is to convert the requirements acquired in the SRS into a format that can
be coded in a programming language.
4. Coding and Unit Testing
In the coding phase software design is translated into source code using any suitable
programming language.
5. Integration and System testing
Integration of different modules is undertaken soon after they have been coded and unit tested.
Integration of various modules is carried out incrementally over several steps.
Alpha testing: Alpha testing is the system testing performed by the development team.
 Beta testing: Beta testing is the system testing performed by a friendly set of customers.
 Acceptance testing: After the software has been delivered, the customer performs
acceptance testing to determine whether to accept the delivered software or reject it.
6. Maintenance
Maintenance is the most important phase of a software life cycle. The effort spent on
maintenance is 60% of the total effort spent to develop a full software. There are three types of
maintenance.

2. Discuss about incremental development model.(5M)

Requirements of Software are first broken down into several modules that can be incrementally
constructed and delivered.

Phases of incremental model

1. Requirement analysis: In Requirement Analysis At any time, the plan is made just for the
next increment and not for any kind of long-term plan. Therefore, it is easier to modify the
version as per the needs of the customer.
2. Design & Development: At any time, the plan is made just for the next increment and not
for any kind of long-term plan.
3. Deployment and Testing: After Requirements gathering and specification, requirements are
then split into several different versions starting with version 1.
4. Implementation: In implementation After the last version (version n), it is now deployed at
the client site.
Requirement Process Model

Types of Incremental Model

1. Staged Delivery Model
2. Parallel Development Model
1. Staged Delivery Model
Construction of only one part of the project at a time.

2. Parallel Development Model

Different subsystems are developed at the same time. It can decrease the calendar time needed
for the development, i.e. TTM (Time to Market) if enough resources are available.

When to use the Incremental Process Model

1. Funding Schedule, Risk, Program Complexity, or need for early realization of benefits.
2. When Requirements are known up-front.
3. When Projects have lengthy development schedules.
4. Projects with new Technology.
.
Characteristics of Incremental Process Model
1. System development is divided into several smaller projects.
2. To create a final complete system, partial systems are constructed one after the other.
3. Priority requirements are addressed first.
Advantages of the Incremental Process Model
1. Prepares the software fast.
2. Clients have a clear idea of the project.
3. Changes are easy to implement.
Disadvantages of the Incremental Process Model
1. A good team and proper planned execution are required.
2. Because of its continuous iterations the cost increases.
3. Issues may arise from the system design if all needs are not gathered upfront throughout
the program lifecycle.

B)Illustrate the Emergence of software engineering.(5M)

• Emergence of Software Engineering

This evolution is the result of a series of innovations and accumulation of experience about
writing good quality programs. Since these innovations and programming experiences are
too numerous, let us briefly examine only a few of these innovations and programming
experiences which have contributed to the development of the software engineering
discipline.
• Early Computer Programming
• High-level Language Programming
• Control Flow-based Design
• Data Structure-oriented Design
• Data Flow-oriented Design
• Object-oriented Design
Other Developments
 • Early Computer Programming
Those programs were usually written in assembly languages. Program lengths were
typically limited to about a few hundreds of lines of monolithic assembly code.

High-level Language Programming

• Computers became faster with the introduction of the semiconductor technology in the
early 1960s. Faster semiconductor transistors replaced the prevalent vacuum tube-based
circuits in a computer.

Control Flow-based Design

• A program’s control flow structure indicates the sequence in which the program’s
instructions are executed.

• Data Structure-oriented Design

• These could now be used to solve more complex problems. Software developers were
tasked to develop larger and more complicated software.
• it is much more important to pay attention to the design of the important data structures
of the program than to the design of its control structure.

Data Flow-oriented Design

The data flow-oriented techniques advocate that the major data items handled by a
system must be identified and the processing required on these data items to produce
the desired outputs should be determined.
• The functions (also called as processes ) and the data items that are exchanged between
the different functions are represented in a diagram known as a data flow diagram
(DFD).
DFDs: A crucial program representation for procedural program design

Object-oriented Design

• Object-oriented design technique is an intuitively appealing approach, where the natural

objects (such as employees, pay-roll-register, etc.) relevant to a problem a r e first
identified and then the relationships among the objects such as composition, reference,
and inheritance are determined. Each object essentially acts as a data hiding (also
known as data abstraction ) entity

3. Differentiate iterative water fall model and V- model. (10M)

1. Iterative Waterfall Model

 Structure: Linear and sequential, but with iterative feedback loops between adjacent
phases.
 Development Process:
 o Progress flows in one direction from one phase to the next (like a waterfall). The
phases include Requirement Analysis, Design, Implementation, Testing, and
Maintenance.
o However, there is feedback allowed between phases, which means developers can
revisit the previous phase if necessary to incorporate changes or correct errors.
 Testing Integration: Testing is carried out only after the implementation phase is
complete, though feedback can result in revisiting previous phases.
 Flexibility: Offers slightly more flexibility than the traditional waterfall model by
incorporating feedback between phases. However, it’s still difficult to implement major
changes once the project has moved into later stages.
 Use Case: Useful when requirements are fairly stable but can still evolve, and the team is
willing to backtrack for small refinements.


2. V-Model (Validation and Verification Model)
 Structure: Expands on the waterfall model by pairing each development phase with a
corresponding testing phase, creating a "V" shape when visualized.
 Development Process:
o On the left side of the "V" are the development stages: Requirements Analysis,
System Design, Architecture Design, Module Design, and Coding.
o On the right side are corresponding validation/testing stages: Unit Testing,
Integration Testing, System Testing, and Acceptance Testing.
o For each development phase, there’s a corresponding testing activity, ensuring
that testing happens concurrently with development.
 Testing Integration: Unlike the iterative waterfall model, testing is planned and
executed alongside each development phase, allowing early detection of defects.
 Flexibility: More rigid than the iterative waterfall model, as the V-Model assumes a clear
set of requirements at the beginning and does not easily accommodate changes once
development has started.
 Use Case: Well-suited for projects with well-defined, unchanging requirements where
the early and continuous testing of individual modules is important.
 

Key Differences:
Aspect Iterative Waterfall Model V-Model
Basic Linear with feedback loops between Linear with corresponding test
Structure adjacent phases phases for each stage
Testing Testing starts after development phase, Testing is planned alongside
Approach but feedback allows rework development at each stage
More flexible than waterfall; allows Less flexible; changes are harder to
Flexibility
revisiting earlier phases accommodate
Error Errors may be detected later during testing Errors can be detected earlier
Detection phase through continuous testing
For projects with clear, well-defined
Suitability For projects with evolving requirements
requirements

4. Demonstrate prototyping model with suitable example.(10M)

• The prototyping model can be considered to be an extension of the waterfall model. This
model suggests building a working prototype of the system, before development of the
actual software.
• Necessity of the prototyping model :
• It is advantageous to use the prototyping model for development of the graphical user
interface (GUI) part of an application
• The prototyping model is especially useful when the exact technical solutions are unclear
to the development team. A prototype can help them to critically examine the technical
issues associated with product development
Prototyping is a key process in software engineering, especially in agile development, where a
model or simulation of the final system is developed early in the process to refine and validate
requirements before the actual development takes place.

Types of Prototyping Models:

1. Throwaway/Rapid Prototyping:
A quick prototype is built with the purpose of understanding the requirements. Once the
feedback is gathered and requirements are clarified, the prototype is discarded, and the actual
system is built from scratch.
2. Evolutionary Prototyping:
A prototype is developed and improved over time, eventually evolving into the final
product. In this case, the prototype is not thrown away, but refined iteratively until it meets the
system’s final requirements.
Incremental Prototyping:
 The system is divided into small modules, and each module is prototyped separately. The
individual prototypes are eventually integrated into the final system.
Extreme Prototyping (For web-based systems):
 A three-phase process where a static mock-up of the system's user interface is developed,
followed by functional screens and then services.

Example for Prototyping Model:

Let’s say a company is developing an online shopping application. The developers use rapid
prototyping to get quick feedback from stakeholders before building the final version of the
system.

Step-by-step Process:
1. Gather Preliminary Requirements:
o The developers conduct meetings with stakeholders to gather high-level
requirements like:
 Login functionality for users
 Product browsing by category
 Shopping cart management
  Payment gateway integration
2. Build the Prototype:
o The development team quickly develops a UI-only prototype with clickable
buttons and flow, but without real functionality. The mock-up includes:
 Main dashboard
 Product pages with filters
 Cart page
 Checkout page
3. Stakeholder Review:
o The stakeholders review the prototype and provide feedback on the design,
usability, and overall user experience.
4. Refine Requirements:
o Based on the feedback, new requirements are gathered and existing requirements
are modified. For example, users request a “wishlist” feature and an advanced
search functionality.
5. Discard the Prototype:
o Once the requirements are clear, the prototype is discarded, and the development
team starts building the actual online shopping application with the refined
requirements.

[Link] spiral model in detail with neat diagram.(10M)

The Spiral Model is a software development methodology that emphasizes iterative development
and risk management. It combines the iterative nature of prototyping with the systematic aspects
of the waterfall model. The primary focus is on risk assessment and reduction throughout the
development process, allowing for continuous refinement and enhancement of the product.

• Each loop of the spiral is called a phase of the software process. The exact number of
phases through which the product is developed can be varied by the project manager
depending upon the project risks. A prominent feature of the spiral model is handling
unforeseen risks that can show up much after the project has started. In this context,
 please recollect that the prototyping model can be used effectively only when the risks in
a project can be identified upfront before the development work starts.
• in the spiral model prototypes are built at the start of every phase. Each phase of the
model is represented as a loop in its diagrammatic representation. Over each loop, one or
more features of the product are elaborated and analyzed and the risks at that point of
time are identified and are resolved through prototyping. Based on this, the identified
features are implemented.

Key Components of the Spiral Model

1. Phases: The Spiral Model consists of four major phases, which are repeated in cycles (or
spirals):
o Planning: Identify objectives, alternatives, and constraints for the project.
o Risk Analysis: Evaluate risks associated with the project and determine how to
manage them.
o Engineering: Develop the software and test it.
o Evaluation: Review the progress and make adjustments based on feedback.
2. Iterative Cycles: Each cycle of the spiral can be considered a mini-project, allowing for
feedback and improvements before moving on to the next iteration.
3. Risk Management: The Spiral Model places significant emphasis on identifying and
mitigating risks early in the development process. This is crucial for projects with high
uncertainty.
4. Customer Feedback: Continuous customer involvement is essential throughout the
development process to ensure the product meets user requirements.

Advantages of the Spiral Model

 Risk Reduction: Allows for early detection and mitigation of risks.
 Flexibility: Changes can be incorporated into the project based on user feedback and
evolving requirements.
 Enhanced Quality: Continuous testing and refinement lead to higher-quality software.
 User Involvement: Frequent customer feedback improves satisfaction and ensures the
product meets user needs.
Disadvantages of the Spiral Model
 Complexity: The model can be complicated to manage, especially for smaller projects.
 Cost: It may require more resources and time due to the iterative nature and risk
assessments.
 Requires Expertise: Effective risk assessment requires skilled professionals, which may
not be available in all teams.
 [Link] prototyping model and incremental model.(10M)

The Prototyping Model and the Incremental Model are both software development
methodologies, but they differ in their approaches to building software systems. Here’s a detailed
differentiation based on concepts typically covered in Rajib Mall's textbook on software
engineering:

Prototyping Model
1. Definition:
o The Prototyping Model involves creating a preliminary version (prototype) of the
software to understand user requirements and refine the final product based on
user feedback.
2. Process:
o Prototype Creation: A prototype is developed quickly, which can be either a
throwaway prototype (discarded after use) or an evolutionary prototype (evolved
into the final product).
o User Evaluation: Users interact with the prototype, providing feedback on its
functionality, design, and usability.
o Refinement: The prototype is refined based on feedback, and this process may
repeat several times until the requirements are clarified.
3. Focus:
o Emphasizes understanding user requirements through iterative feedback and
visual representation of the system.
4. Advantages:
o Helps in clarifying ambiguous requirements.
o Allows users to visualize the system early in development.
o Reduces risks by uncovering problems early.
5. Disadvantages:
o Can lead to scope creep if user expectations are not managed.
o Prototypes can sometimes be mistaken for the final product, leading to inadequate
testing.
Incremental Model
• This life cycle model is sometimes referred to as the successive versions model and
sometimes as the incremental model. In this life cycle model, first a simple working
system implementing only a few basic features is built and delivered to the customer.
Over many successive iterations successive versions are implemented and delivered to
the customer until the desired system is realized

1. Definition:
o The Incremental Model breaks the software development process into smaller,
manageable increments or modules, which are developed and delivered
sequentially.
2. Process:
o Incremental Development: The software is developed in increments, with each
increment adding functional capabilities to the previous version.
o Frequent Delivery: Each increment is built, tested, and delivered to the user for
feedback.
o Integration: New increments are integrated with existing functionalities,
progressively enhancing the system.
3. Focus:
o Emphasizes delivering functional parts of the system at regular intervals to ensure
early deployment and user involvement.
 4. Advantages:
o Provides a working version of the software earlier in the development process.
o Users can provide feedback on each increment, allowing for adjustments to future
increments.
o Reduces overall project risk by developing smaller parts.
5. Disadvantages:
o Requires careful planning and management to ensure each increment integrates
well with others.
o May lead to incomplete systems if not managed properly.

Key Differences
Aspect Prototyping Model Incremental Model
Clarifying requirements through user Delivering functional software in parts
Purpose
feedback. or increments.
Develops a prototype for evaluation Builds the system in increments,
Process
and refinement. integrating each part.
User High, as users interact with prototypes Continuous, with feedback after each
Involvement frequently. increment.
Development Iterative and may involve multiple Sequential, focusing on one increment
Cycle prototypes. at a time.
Risk Helps identify risks related to user Reduces risks by delivering and
Management requirements. testing increments early.
Prototype may be discarded or evolve Final product is built up from
Final Product
into final product. increments.

7.A)Describe the Software development project in detail.(5M)

• A software service usually involves either development of a customized software or

development of some specific part of a software in an outsourced mode.
• A customized software is developed according to the specification drawn up by one or at
most a few customers.
• In a customized software development project, a large part of the software is reused from
the code of related software that the company might have already developed
• Programs versus Products
• Types of Software Development Projects
• Software products
• Software services

A software development project is typically defined as a sequence of activities organized to

produce a software product. Here’s a detailed overview based on the concepts from the book:
1. Requirements Gathering and Analysis:
o This is the initial phase, where the project team collects and documents what the
users need from the system.
o Functional requirements specify what the system should do, while non-functional
requirements outline the system’s performance, security, and usability aspects.
 o Effective requirement analysis prevents misunderstandings and sets a solid
foundation for further development.
2. System Design:
o In this phase, high-level design and detailed design are created. The high-level
design outlines the system’s architecture and breaks down the software into
modules or components.
o Detailed design goes further into specifying each module's functionality, data
structures, and interfaces.
o This phase ensures that the team has a clear structure for coding and future
maintenance.

3. Implementation:
o During implementation, developers write the actual code for the system based on
the design specifications.
o Each module is coded separately and may undergo unit testing to ensure
individual components work as expected.
o This phase is heavily dependent on the chosen programming language and coding
standards.
4. Testing:
o Software testing is a critical phase to find and fix any defects or errors. Testing
phases typically include unit testing, integration testing, system testing, and
acceptance testing.
5. Deployment:
o The deployment phase involves installing the software in the target environment,
which could be the user’s site, a server, or a cloud platform.
o This phase often requires the setup of databases, network configurations, and
hardware compatibility checks to ensure smooth operation.
6. Maintenance:
o Once deployed, software often needs regular maintenance for fixing bugs,
improving performance, and adapting to changes in the environment.
7. Project Management:
o Project management practices are essential throughout all phases, involving
planning, scheduling, resource allocation, and risk management.
o Effective project management includes setting clear milestones, using project
tracking tools, and ensuring continuous communication among team members.

b)How computer system engineering differ from traditional software engineering?

Explain.(5M)
The distinction between computer system engineering and traditional software engineering is
emphasized based on the scope, objectives, and focus of each field.
1. Scope:
o Software Engineering: Primarily concerned with developing and maintaining
software applications and systems. The focus is on software components, such as
requirements gathering, design, coding, testing, and maintenance. Computer
System Engineering: Encompasses a broader scope that includes both software
and hardware. It involves designing entire computer systems, often considering
hardware components, embedded systems, operating systems, and network
configurations.
 2. Objectives
3. Software Engineering: The main objective is to produce high-quality, reliable, and
efficient software solutions that meet user requirements
4. Computer System Engineering: This field aims to create optimized and fully integrated
systems where both hardware and software components work seamlessly together.
5. Focus on Hardware and Embedded Systems:
o Software Engineering: Hardware considerations are minimal and limited to the
software’s compatibility with different platforms. Software engineers typically
design systems that can be easily transferred across hardware environments
without requiring substantial modifications.
6. Computer System Engineering: There is a strong emphasis on hardware, often
involving embedded systems where software and hardware are closely tied.
7. Design and Development Approaches:
o Software Engineering: Emphasizes modularity, reusability, and scalability of
software. Development follows structured methodologies (like Agile, Waterfall)
that prioritize user-centered designs and software testing.
8. Computer System Engineering: Requires a holistic approach, where both software and
hardware requirements are considered from the start.
9. Application Domains:
o Software Engineering: Generally applied in domains where software can run on
generic hardware systems, such as web applications, business software, and
mobile apps.
o Computer System Engineering: Often applied in specialized domains, such as
embedded systems, robotics, IoT, telecommunications, and aerospace, where tight
integration between hardware and software is critical.

[Link] about Rapid application development model in detail.(10M)

It is especially useful in projects where requirements are expected to evolve frequently or need to
be clarified through user feedback.
Working of RAD
The time planned for each iteration is called a time box. Each iteration is planned to enhance the
implemented functionality of the application by only a small amount. During each time box, a
quick-and-dirty prototype-style software for some functionality is developed.

Key Characteristics of the RAD Model:

1. Prototyping and Iterative Development:
o RAD focuses on quickly developing prototypes to help users and stakeholders
visualize and understand how the final product will function.
o Iterative cycles allow for continuous user feedback, with each iteration bringing
refinements and improvements to the product.
2. Component-Based Approach:
o Software components are developed independently, allowing teams to work in
parallel and rapidly assemble different parts.
o These components can be reused in future projects, increasing efficiency and
reducing development time.
3. Emphasis on User Feedback:
o RAD model involves the users and stakeholders extensively throughout the
development process.
 o Regular feedback from users is collected to ensure the product aligns with their
requirements and expectations, which makes RAD effective for projects with
uncertain or evolving requirements.
4. Time-Boxed Development:
o The RAD model operates under time constraints, dividing the project into time-
boxed phases (often weeks or months).
o Each phase is focused on delivering a prototype or functional component, aiming
to produce a working system quickly rather than a fully optimized one from the
start.
5. Reduced Formal Planning and Documentation:
o Unlike traditional models that emphasize heavy documentation, RAD uses
minimal documentation to keep the focus on rapid coding and testing.
o Documentation is still present but limited, as the priority is delivering functional
software to the user quickly.
Phases of the RAD Model:
1. Requirements Planning:
o In this initial phase, developers, users, and stakeholders meet to identify the
system’s objectives and constraints.
o Requirements are defined at a high level without diving into extensive detail, as
the focus is on developing a workable solution quickly.
2. User Design Phase:
o This is an interactive phase where users actively participate in designing the
system alongside developers.
o Prototyping tools and techniques allow users to see visual representations and
provide feedback to developers directly.
3. Construction Phase:
o In this phase, the actual coding, unit testing, and system testing are done. Due to
the prototypes created in the user design phase, development teams have a clear
guide for building the system.
o Feedback is continually incorporated, and changes are made rapidly to enhance
usability and functionality based on user responses.
4. Cutover (Transition) Phase:
o Once the system is constructed and has passed basic testing, it is moved to the
cutover phase, which involves final testing, data conversion, and training for
users.
o After any final adjustments, the system is ready for full deployment.

Advantages of RAD:
 Speed: The time-boxed, iterative nature of RAD allows for faster delivery, making it
ideal for projects requiring rapid completion.
 Flexibility and Adaptability: RAD is highly adaptable to changing requirements since
user feedback can be implemented quickly in each iteration.
 User Satisfaction: Continuous user involvement helps ensure that the product aligns
closely with user needs, leading to high satisfaction.

Disadvantages of RAD:
 Resource Intensive: Requires experienced developers and designers, as well as users
who are consistently available for feedback and testing.
  Limited Scalability: RAD may not be suitable for large, complex projects due to its
focus on rapid prototyping and minimal documentation.
 Reduced Quality Control: The emphasis on speed can compromise thorough testing and
code quality if not managed carefully.

Applicability of the RAD Model:

• The following are some of the characteristics of an application that indicate its suitability
to RAD style of development:
• Customised software: As already pointed out a customised software is developed for
one or two customers only by adapting an existing software.
• Non-critical software: The RAD model suggests that a quick and dirty software should
first be developed and later this should be refined into the final software for delivery.
• Highly constrained pro ject schedule: RAD aims to reduce development time at the
expense of good documentation, performance, and reliability. Naturally, for projects with
very aggressive time schedules, RAD model should be preferred.
• Large software: Only for software supporting many features (large software) can
incremental development and delivery be meaningfully carried out.
.