󾠮

unit 1

❓ What are the 4 main roles of a project manager? (2022) 2-mks

The four main roles of a project manager are:

1. Planning and Scope Management:

The project manager defines the project's objectives, deliverables, and scope.

They create a detailed project plan, including timelines, milestones, and resources required.

They identify risks and develop strategies to mitigate them.

2. Team Leadership and Communication:

The project manager builds and leads a team, assigning tasks and responsibilities.

They provide clear direction and guidance to team members.

They facilitate effective communication among team members, stakeholders, and clients.

3. Risk Management:

The project manager identifies potential risks that could impact project success.

They assess the severity and likelihood of risks and develop mitigation plans.

They monitor risks throughout the project and take corrective actions as necessary.

4. Monitoring and Control:

The project manager tracks project progress against the plan.

They ensure that tasks are completed on time and within budget.

They conduct regular project status meetings, review reports, and make adjustments when
needed.

unit 1 1
 These roles are crucial for a project manager to effectively plan, execute, and complete projects while
ensuring that goals are met and stakeholders are satisfied.

❓ Explain waterfall model with its advantages and disadvantages. (2022)

The waterfall model is a sequential and linear software development approach that consists of several
distinct phases, each building upon the previous one. Here's an explanation of the waterfall model:

1. Requirements Gathering:

In this initial phase, project requirements are gathered

and documented.

The project team interacts with stakeholders to

understand their needs and expectations.

The requirements are defined in detail, including

functionalities, constraints, and goals.

2. System Design:

Once the requirements are defined, the system design phase begins.

The project team creates a comprehensive design for the software system.

The design includes architectural decisions, modules, interfaces, and data structures.

3. Implementation:

In this phase, the actual coding and programming take place.

The development team follows the design specifications to build the software system.

The code is written, tested, and integrated into a complete solution.

4. Testing and Verification:

The software is thoroughly tested to ensure that it meets the specified requirements.

Various testing techniques are employed, such as unit testing, integration testing, and system
testing.

Bugs and issues are identified, reported, and fixed to improve the quality of the software.

5. Deployment and Maintenance:

Once the software is deemed stable and error-free, it is deployed to the production environment.

Users can start utilizing the software for its intended purpose.

Maintenance and support activities are carried out to address any future issues or updates.

The waterfall model follows a sequential approach, with each phase being completed before moving on to
the next one. It emphasizes a structured and planned process, making it easier to manage projects with
well-defined requirements.
Advantages of the Waterfall Model:

1. Clear and Structured Process: The waterfall model provides a clear and structured approach to
software development, making it easier to understand and follow.

unit 1 2
 2. Well-Defined Requirements: The upfront requirements gathering phase ensures that project
requirements are clearly defined and documented before moving forward, reducing ambiguity.

3. Easy Project Management: The sequential nature of the model simplifies project management, as
each phase has distinct deliverables and milestones, making it easier to track progress.

4. Suitable for Stable Requirements: The waterfall model works well when the project requirements are
stable and unlikely to change significantly throughout the development process.

Disadvantages of the Waterfall Model:

1. Limited Flexibility: The linear nature of the waterfall model makes it challenging to accommodate
changes or new requirements that arise during development. Once a phase is completed, it is difficult
to go back and make changes without disrupting the entire process.

2. Late Error Detection: Testing is typically conducted towards the end of the development cycle, which
means errors or issues may not be detected until the later stages. This can result in increased costs
and time for fixing problems.

3. Lack of Customer Involvement: In the waterfall model, customer or stakeholder involvement is limited
to the initial requirements gathering phase. This may lead to a mismatch between the final product
and user expectations.

4. Lengthy Development Time: The sequential nature of the waterfall model can result in longer
development times, as each phase must be completed before moving on to the next. This can be a
disadvantage in fast-paced or dynamic project environments.

It's important to consider these advantages and disadvantages when deciding whether to use the
waterfall model for a particular software development project.

❓ What is re-engineering in software engineering? (2022)

Re-engineering in software engineering refers to the process of modifying or transforming existing

software systems to improve their functionality, performance, maintainability, or other non-functional
aspects. It involves making significant changes to the software while preserving its intended purpose and
value. Here's a further explanation of re-engineering:

1. Evaluation and Analysis:

The existing software system is evaluated and analyzed to identify its strengths, weaknesses, and
areas that require improvement.

This evaluation includes assessing the software's architecture, code quality, documentation,
performance, and other relevant factors.

2. Goals and Objectives:

Clear goals and objectives are established for the re-engineering process. These goals can
include enhancing functionality, improving scalability, modernizing technology, or optimizing
performance.

3. Design and Planning:

A detailed plan is developed to guide the re-engineering process, including the proposed
changes, sequence of tasks, resource allocation, and timelines.

unit 1 3
 The design phase involves creating a new system design or modifying the existing design to
accommodate the desired improvements.

4. Implementation:

The actual changes to the software system are implemented according to the re-engineering
plan.

This may involve rewriting or restructuring code, replacing outdated components, integrating new
functionalities, or optimizing algorithms.

5. Testing and Validation:

The re-engineered software undergoes rigorous testing to ensure that it meets the defined goals
and requirements.

Different types of testing, such as functional testing, performance testing, and regression testing,
are conducted to verify the changes and identify any issues.

6. Deployment and Maintenance:

Once the re-engineered software is deemed stable and functional, it is deployed to the production
environment.

Ongoing maintenance and support activities are carried out to address any potential issues,
incorporate user feedback, and make further improvements if necessary.

Re-engineering aims to improve the overall quality, maintainability, and efficiency of existing software
systems. It can be a cost-effective approach compared to building a new system from scratch, especially
when the existing system still provides value but requires significant updates or enhancements.

❓ What are the five steps in agile development? (2022)

Agile development follows a flexible and iterative approach to software development. The five steps in
Agile development, often referred to as the Agile development lifecycle, are as follows:

1. Requirements Gathering and Planning:

In this step, the project team collaborates with stakeholders to gather requirements and define
project goals.

The team creates a prioritized backlog of user stories or features to be implemented.

Planning involves estimating the effort required for each item and deciding on the scope of work
for the upcoming iteration or sprint.

2. Iterative Development:

Agile development is characterized by short iterations called sprints, typically lasting 1-4 weeks.

The development team selects a set of user stories from the backlog to work on during the sprint.

They break down the selected user stories into smaller tasks and begin implementing them.

3. Continuous Integration and Testing:

As development progresses, the team regularly integrates and tests the implemented features.

unit 1 4
 Continuous integration ensures that the changes made by different team members are combined
and tested together to identify any integration issues.

Automated and manual testing is performed to verify the functionality and quality of the
implemented features.

4. Regular Reviews and Adaptation:

At the end of each sprint, a review or demo is conducted to showcase the completed features to
stakeholders.

Feedback is collected, and any necessary adaptations or changes are discussed and
incorporated into future sprints.

This continuous feedback loop allows for flexibility and course correction throughout the
development process.

5. Delivery and Iteration:

Once the desired set of features is implemented and tested, they are deployed to the production
environment.

This delivery may occur at the end of each sprint or after multiple sprints, depending on the
project's timeline and objectives.

The development process continues with subsequent iterations, incorporating feedback,

reprioritizing the backlog, and adding new features.

Agile development promotes collaboration, adaptability, and continuous improvement. The iterative nature
of the process allows for flexibility and quick response to changes, while regular reviews and adaptation
ensure that the project stays aligned with stakeholder expectations.

❓ What is legacy software? (2020) 2-mks

Legacy software refers to older or outdated software systems that are still in use but may no longer be
actively maintained or updated. These software systems were developed using technologies, frameworks,
or programming languages that have since been superseded by newer and more advanced alternatives.
Here's a further explanation of legacy software:

1. Age and Obsolescence:

Legacy software typically refers to software that has been in use for a considerable period, often
several years or even decades.

It may have been developed using outdated programming languages, frameworks, or hardware
platforms that are no longer widely supported or used.

2. Limited Maintenance and Updates:

Legacy software may have reached a point where it receives limited or no updates, bug fixes, or
security patches.

This lack of maintenance can result in compatibility issues, performance problems, and potential
security vulnerabilities.

3. Technological Misalignment:

unit 1 5
 Legacy software may not align well with current technological trends, making it difficult to
integrate with modern systems or take advantage of new features and capabilities.

It may lack support for mobile platforms, cloud computing, or other emerging technologies.

4. Challenges and Risks:

Working with legacy software can pose challenges due to limited documentation, outdated
development practices, and scarce expertise in older technologies.

The risks associated with legacy software include reduced efficiency, higher maintenance costs,
and difficulties in scaling or adapting the software to meet changing business needs.

5. Strategic Decision-making:

Organizations using legacy software face the decision of whether to replace, modernize, or
continue using the existing system.

Factors such as budget constraints, business priorities, and the level of technical debt influence
these decisions.

It's important to note that not all older software is considered legacy software. If a software system is
actively maintained, updated, and aligned with current technologies, it may not fall into the legacy
category. Legacy software typically refers to systems that have become outdated and present challenges
in terms of maintenance, compatibility, and technological integration.

❓ Explain Capability Maturity Model Integration (CMMI). (2020)

Capability Maturity Model Integration (CMMI) is a framework that helps organizations improve their
processes and achieve higher levels of maturity in software development and project management. It
provides a set of best practices and guidelines for organizations to assess, plan, and improve their
capabilities. Here's an explanation of CMMI:

1. Levels of Maturity:

CMMI defines five levels of maturity: Initial, Managed, Defined, Quantitatively Managed, and
Optimizing.

Each level represents a stage of process improvement and indicates the organization's capability
to deliver high-quality products and services.

2. Process Areas:

CMMI consists of multiple process areas, each focusing on specific aspects of process
improvement and organizational capabilities.

Examples of process areas in CMMI include Requirements Management, Project Planning, Risk
Management, Configuration Management, and Measurement and Analysis.

3. Continuous Improvement:

CMMI emphasizes continuous improvement by providing guidelines for organizations to identify

areas for improvement and define action plans.

It encourages organizations to set objectives, collect data, and use metrics to measure and
monitor process performance.

unit 1 6
 4. Appraisal and Evaluation:

Organizations can conduct formal appraisals to assess their process maturity and determine their
current level according to the CMMI model.

The appraisal results help organizations identify strengths, weaknesses, and areas requiring
improvement.

5. Tailoring and Adoption:

CMMI is a flexible framework that allows organizations to tailor its practices and processes
according to their specific needs and goals.

Organizations can choose the relevant process areas and define the level of implementation that
aligns with their business objectives.

6. Benefits and Impact:

Implementing CMMI can bring several benefits, including improved productivity, enhanced quality,
reduced risks, better project management, and increased customer satisfaction.

It helps organizations establish standardized and repeatable processes, leading to more efficient
operations and improved delivery of products and services.

CMMI defines five levels of maturity that organizations can achieve. These levels represent stages of
process improvement and indicate the organization's capability to deliver high-quality products and
services. Here are the levels of CMMI:

1. Level 0: Incomplete:

At this stage work “may or may not get completed.” Goals have not been established at this point and
processes are only partly formed or do not meet the organizational needs.

2. Level 1: Initial:

At this level, processes are unpredictable, poorly controlled, and often ad hoc.

Project success relies heavily on individual skills and efforts, rather than standardized processes.

There is a lack of consistent practices and documentation, resulting in inconsistent outcomes.

3. Level 2: Managed:

At this level, organizations start to establish basic project management processes.

Project activities and tasks are planned, tracked, and controlled to ensure predictable outcomes.

Processes are documented, and some level of standardization is achieved.

The focus is on meeting project requirements within defined constraints.

4. Level 3: Defined:

At this level, organizations have well-defined and documented processes.

Standardized processes are used across the organization, promoting consistency and
repeatability.

There is a focus on process improvement and optimizing the use of resources.

Processes are tailored to suit project needs while adhering to defined standards.

5. Level 4: Quantitatively Managed:

unit 1 7
 At this level, organizations use quantitative data to manage and control processes.

Processes are measured, and performance metrics are collected and analyzed.

The focus is on quantitative management and process performance optimization.

Organizations strive to achieve a higher degree of predictability and control.

6. Level 5: Optimized:

At this highest level of maturity, organizations continually strive to improve their processes.

Continuous process improvement is ingrained in the organization's culture.

The focus is on innovation, optimizing performance, and identifying and addressing root causes of
issues.

Processes are proactively improved based on feedback, lessons learned, and industry best
practices.

Each level builds upon the previous one, representing an increasing level of maturity and capability.

❓ What is RAD model? Explain applications and features of RAD model. (2020)

The RAD (Rapid Application Development) model is a way to develop software quickly. It focuses on
making prototypes and working closely with the people who will use the software.

The RAD model is a flexible and collaborative way to develop software quickly. It focuses on making
prototypes and involving users throughout the process. It's good for projects with changing requirements
and a need for fast delivery of functional software.
Here's an explanation of the RAD model:

1. Applications of RAD Model:

RAD is good for projects that need to be finished quickly and have changing requirements.

It works well for making small to medium-sized software, prototypes, and proof-of-concept
applications.

RAD is often used when it's important to get feedback from users and involve them in the
development process.

2. Features of RAD Model:

Rapid Iterations: RAD breaks the work into small parts and quickly builds and tests them to get
feedback early on.

Prototyping: RAD focuses on making examples of the software to show how it will work and get
feedback from users.

Collaborative Approach: RAD encourages working closely with the people who will use the
software to make sure it meets their needs.

Reusable Components: RAD uses pre-built parts to make development faster and keep the
software consistent.

Timebox Approach: RAD sets specific time limits for each part of the work to stay on schedule.

unit 1 8
 Concurrent Activities: RAD allows doing different parts of the work at the same time to speed up
the development process.

3. Advantages of RAD Model:

Faster Time-to-Market: RAD helps deliver software quickly because it breaks the work into small
parts and gets feedback early.

Increased Stakeholder Involvement: RAD involves the people who will use the software to make
sure it meets their needs and keeps them happy.

Improved Quality: RAD finds and fixes problems early by making prototypes and getting
feedback, so the software ends up being better.

Flexibility and Adaptability: RAD can handle changes in requirements because it's designed to be
flexible and adapt to new needs.

4. Limitations of RAD Model:

Dependency on User Involvement: RAD needs the active involvement of users and stakeholders,
which can be hard to manage sometimes.

Complexity Management: RAD can get complicated if not managed well, so it's important to keep
track of everything and document it properly.

Limited Scalability: RAD works best for smaller projects, so it may not be as effective for big and
complex software systems.

❓ Explain spiral model with its advantages and disadvantages (2020)

The spiral model is a way to develop software that combines different methods. It focuses on managing
risks and getting feedback throughout the development process. It combines elements of both waterfall
and iterative development methodologies. Here's an explanation of the spiral model in simpler language:

1. Spiral Model Overview:

The spiral model breaks the software development process into smaller parts called "spirals."

Each spiral has different phases, like planning, risk analysis, development, and evaluation.

It's a flexible model that can adapt to changes and uncertainties in the project.

The spiral model typically consists of four main phases: Planning, Risk Analysis, Engineering, and
Evaluation.

Planning: Requirements are gathered, project objectives are defined, and alternative
solutions are evaluated.

Risk Analysis: Potential risks and uncertainties are identified, analyzed, and mitigation
strategies are planned.

Engineering: Software is developed, implemented, and tested in smaller increments or

iterations.

Evaluation: The software is evaluated through testing, user feedback, and customer reviews
to assess its functionality and quality.

2. Advantages of the Spiral Model:

unit 1 9
 Managing Risks: The spiral model helps identify and deal with risks early on, making the project
safer.

Flexibility: It can handle changes in requirements and easily incorporate feedback from users.

Incremental Development: Software is developed and released in small parts, allowing for
continuous improvement.

Involving Stakeholders: The model encourages feedback and involvement from the people who
will use the software.

3. Disadvantages of the Spiral Model:

Complexity: The spiral model can be complex to manage and may need experienced people to
handle it well.

Costly: Developing in iterations can take more time and resources, which can make it more
expensive.

Time-Consuming: It may take longer to complete a project using the spiral model because of the
iterative nature.

Documentation Challenges: Keeping track of changes and managing documentation can be

difficult.

4. Suitable Applications:

The spiral model is good for big and complex projects where risks need careful management and
requirements may change.

It's helpful when there's a lot of uncertainty and getting early feedback is important.

5. Collaboration and Communication:

Success with the spiral model depends on working well together and communicating effectively
between the development team, stakeholders, and project managers.

❓ "Software engineering is an art as well science" Justify this statement. (2019) 2-mks

"Software engineering is an art as well as a science" because:

1. Artistic Element: Software engineering involves creativity, problem-solving, and designing user-
friendly solutions. It requires thinking outside the box and finding innovative approaches to software
development.

2. Scientific Element: Software engineering follows systematic methodologies, uses logical thinking, and
relies on empirical evidence to ensure reliable and high-quality software. It incorporates mathematical
principles, algorithms, and data analysis.

In summary, software engineering combines creativity and problem-solving (artistic element) with
systematic methodologies and empirical evidence (scientific element) to develop innovative and reliable
software solutions.

unit 1 10
 ❓ Assume that you are a project manager in a company which is at CMM level 3 and need to
upgrade to CMM level 4. Suggest the key process areas on which you should stress in order to
attain the next level (2019)

As a project manager trying to upgrade the company from CMM Level 3 to Level 4, there are certain
areas you should focus on. These areas will help improve the software development process and reach
the desired level. Here are the key areas to stress:

1. Keeping Track of Projects:

Use techniques to measure and control project performance.

Collect and analyze project data to make informed decisions and predict future outcomes.

Use metrics to measure project progress, productivity, and quality.

2. Improving Organizational Processes:

Understand and improve the organization's processes.

Identify areas for improvement and remove bottlenecks.

Measure process performance and track improvements over time.

3. Managing Processes with Data:

Use statistical techniques to manage and control processes.

Collect and analyze process data to identify problems and take corrective actions.

Set goals for process improvement and use data to track progress.

4. Managing Requirements:

Have a clear process for capturing, analyzing, and managing project requirements.

Ensure requirements are consistent and meet customer needs.

Control and track changes to requirements throughout the project.

5. Integrated Project Management:

Establish a comprehensive project management process that brings different activities together.

Coordinate and integrate project planning, risk management, quality assurance, and configuration
management.

Encourage effective communication and collaboration among team members and stakeholders.

6. Managing Risks:

Have a proactive process to identify, assess, and handle project risks.

Monitor and update the risk management plan throughout the project.

Take steps to reduce the impact of potential risks.

By focusing on these areas, the company can improve project management practices, enhance overall
performance, and meet the requirements for CMM Level 4.

unit 1 11
 ❓ Assume that you are in charge for developing an online gaming system for a company. The
customer has suggested that they would first like to see a working model of the project and
then suggest further changes. Your team has a divided view, one half is insisting in using the
Prototyping model and the other half is insisting to use Component Assembly Model. Decide
and justify your choice. (2019)

When deciding between the Prototyping model and the Component Assembly Model for developing an
online gaming system, it's important to consider the project requirements and the preferences of the
customer. Here's a decision and justification for choosing the appropriate model:

Considering the customer's suggestion to see a working model first and then suggest further changes, the
Prototyping model would be a suitable choice for the following reasons:

1. Customer Involvement: The Prototyping model allows the customer to be actively involved in the
development process. They can see and try out a working prototype of the game early on. This helps
them understand how it will work and give feedback for improvements.

2. Making Changes Quickly: With the Prototyping model, the development team can make changes to
the game based on the customer's feedback. They can create new versions of the prototype and
keep improving it based on what the customer wants.

3. Seeing the Game Design: The Prototyping model lets the customer see how the game will look and
feel. They can get an idea of the graphics, user interface, and how everything will work together. This
helps in refining the design and making any necessary changes.

4. Reducing Risks: By using prototypes, any problems or challenges can be identified early on. The
Prototyping model helps the team test the game's feasibility and fix any major issues before they
become big problems.

5. Adapting to Changes: The Prototyping model is good for handling changes. As the customer tries out
the prototype, they may suggest new features or changes. The team can easily incorporate these
changes and make the game better.

While the Component Assembly Model has its benefits, the Prototyping model is better for this situation. It
matches the customer's preference for seeing a working model first, allows for quick changes, helps
visualize the game design, reduces risks, and adapts well to customer feedback.

❓ Assume that you are in charge for developing a project that manages the data coming from
stock market. You have already done similar type of projects in past and have a huge repository
of objects and classes for the purpose. Suggest and justify which software development model
is best suited for the project. (2019)

For developing a project that manages data from the stock market, the best choice would be the Reuse-
Oriented Model. Here's why:

1. Use What You Already Have: You have a collection of ready-made objects and classes from past
similar projects. With the Reuse-Oriented Model, you can make use of these existing components
instead of starting from scratch.

2. Save Time: By reusing these components, you can speed up development. You don't have to build
everything from the beginning, so you can assemble the necessary features quickly.

unit 1 12
 3. Trustworthy Components: Since the objects and classes have already been used in previous projects,
they have been tested and proven to work. This means you can rely on their quality and stability.

4. Keep Things Consistent: Reusing components ensures consistency across projects. You can
maintain a standard approach and avoid introducing inconsistencies or mistakes.

5. Adaptability: The Reuse-Oriented Model allows for flexibility. If new requirements come up, you can
modify the existing components to meet those needs. This helps in accommodating changes in the
future.

6. Cost Savings: By reusing components, you can save on development costs. You don't have to spend
as much time and effort on designing and implementing everything from scratch.

By choosing the Reuse-Oriented Model, you can take advantage of your existing objects and classes,
leading to faster development, reliable components, consistency, flexibility, and cost savings. This model
suits your situation of having a repository of reusable components for managing stock market data.

❓ What are the fundamental activities of a software process? (dec-2018) 2-mks

The fundamental activities of a software process include:

1. Understanding Requirements:

Gathering and analyzing what the software needs to do.

Making sure everyone agrees on the requirements.

2. Designing the Software:

Creating a plan for how the software will work.

Breaking it down into smaller parts and deciding how they fit together.

3. Writing the Code:

Turning the design into actual programming code.

Testing and checking the code for errors.

4. Testing the Software:

Checking that the software works as intended.

Finding and fixing any problems or mistakes.

5. Deploying and Integrating:

Getting the software ready to be used by others.

Making sure it works well with other systems, if needed.

6. Maintaining and Updating:

Fixing issues and making improvements after the software is in use.

Keeping the software up to date and meeting changing needs.

7. Managing the Project:

Planning and organizing the software development.

Keeping track of progress, resources, and timelines.

unit 1 13
 These activities are important for creating and managing software effectively. They ensure that the
software meets requirements, works correctly, and can be maintained and improved over time.

❓ Explain incremental model. List out its merits and demerits. (dec-2018)

The incremental model is an approach to software development that involves breaking down the project
into smaller, manageable increments or iterations. Each increment adds functionality to the software,
building upon the previous increments. Here's an explanation of the incremental model:

1. Requirements Gathering: Initially, the overall requirements of the software are identified. However,
instead of gathering all the requirements at once, the focus is on capturing the most critical and
essential features.

2. Incremental Development: Instead of trying to do everything at the same time, we break the project
into smaller parts or "increments." Each increment adds a new piece of functionality to the software.

3. Design and Coding: For each increment, we plan how it should work and then write the code to make
it happen. We make sure that each piece works properly on its own.

4. Getting Feedback: After completing an increment, we show it to the users or stakeholders. They tell
us what they like and what could be better. Their feedback helps us improve the next increment.

5. Repeating the Process: We keep going through these steps, building one increment at a time and
getting feedback after each one. Gradually, we add more and more functionality to the software.

Advantages of the Incremental Model:

Early Use: Users can start using the software sooner because we deliver usable increments
throughout the development process.

Flexibility: We can easily make changes and improvements based on user feedback since we work on
smaller increments.

Reducing Risks: By focusing on small parts at a time, we can find and fix problems early, reducing
overall risks.

User Involvement: Users get to be a part of the development process by providing feedback, ensuring
the software meets their needs.

Disadvantages of the Incremental Model:

Complexity: Managing multiple increments and making sure they fit together can be a bit complex.

Coordination: We need to coordinate the work on different increments to make sure everything works
well together.

Feature Overload: Without careful control, there's a risk of adding too many features and making the
software more complicated than necessary.

The incremental model is a good choice when we don't have all the requirements at the beginning, when
it's important to deliver usable software early, and when we want continuous user feedback to shape the
development process. It allows us to gradually build the software, piece by piece, while incorporating
improvements and changes along the way.

unit 1 14
 ❓ Write down the major characteristics of software. Illustrate with a diagram that the software
does not wear out. (dec-2018)

Here are the major characteristics of software and an illustration depicting that software does not wear
out:
Major Characteristics of Software:

1. Intangibility: Software is intangible, meaning it cannot be touched or felt physically. It consists of

instructions, code, and data that are processed by computers to perform specific tasks.

2. Flexibility: Software can be easily modified or updated to accommodate changing requirements or

address issues. It allows for flexibility in functionality, design, and configurations.

3. Scalability: Software can be designed to handle different scales of usage, from small-scale
applications to large-scale systems, without significant rework or performance degradation.

4. Reproducibility: Software can be reproduced and distributed with ease. Once developed, it can be
copied and deployed on multiple devices or servers, enabling widespread usage.

5. Maintainability: Software can be maintained and updated to fix bugs, add new features, improve
performance, or adapt to changing technologies. It allows for the longevity and sustainability of
software systems.

6. Complexity: Software can be highly complex, involving intricate algorithms, data structures, and
interactions. Managing this complexity requires careful design, testing, and documentation.

7. Reliability: Software can be designed and tested to perform reliably under specified conditions,
consistently delivering the intended functionality without unexpected errors or failures.

Illustration: Software Does Not Wear Out

[Diagram Description]:
The diagram depicts a comparison between physical objects (represented by a worn-out shoe) and
software (represented by a computer screen with software code). The physical object (shoe) shows signs
of wear and tear, including visible damage and deterioration. On the other hand, the software code
remains intact and unaffected, representing the characteristic that software does not wear out.
[Explanation]:
The illustration emphasizes the intangible nature of software. While physical objects like shoes undergo
wear and tear over time, software remains unchanged in its digital form. Unlike physical objects that can
physically degrade due to usage, exposure to elements, or aging, software can be continuously used
without experiencing wear and tear. This highlights one of the unique characteristics of software – its
ability to endure and maintain its original form and functionality regardless of usage or time.
By illustrating this distinction, we emphasize that software, being intangible, does not deteriorate or wear
out like physical objects do. This characteristic of software contributes to its longevity and allows for long-
term usage without the need for replacement or restoration due to physical degradation.

❓ Explain win-win spiral model. (may-2018)

The Win-Win Spiral Model is an extension of the Spiral Model that specifically focuses on the
requirements negotiation process. It aims to ensure that all stakeholders' concerns and objectives are

unit 1 15
 taken into consideration and effectively addressed during the software development life cycle. Let's
understand the Win-Win Spiral Model in more detail:

1. Iterative Approach: The development process is divided into multiple cycles or iterations. It consists of
multiple cycles or iterations, each involving stages of planning, risk analysis, development, and
evaluation.

2. Requirements Negotiation: There is a strong emphasis on discussing and understanding the needs of
all stakeholders. It recognizes that different stakeholders may have varying requirements, priorities,
and expectations.

3. Stakeholder Collaboration: Active participation and collaboration among stakeholders are

encouraged. It promotes open and transparent communication.

4. Conflict Resolution: Conflicts are taken seriously, and efforts are made to find solutions that satisfy
everyone.

5. Mutually Beneficial Agreements: The goal is to reach agreements that benefit all stakeholders. It
strives to create win-win situations where all parties involved feel that their needs and objectives are
being met.

6. Continuous Refinement: The software is continuously improved based on feedback and changes are
made as needed.

Merits of the Win-Win Spiral Model:

Happy stakeholders: The model focuses on making everyone involved in the project happy and
satisfied.

Better collaboration: It encourages working together and communicating openly, leading to better
understanding and fewer misunderstandings.

Conflict resolution: The model helps resolve conflicts effectively, leading to better relationships among
team members.

Adaptability: It allows for flexibility and adjustments as per changing requirements and risks.

Continuous improvement: The model promotes making ongoing improvements based on feedback.

Demerits of the Win-Win Spiral Model:

Time and resource-intensive: It may require more time and resources to complete multiple cycles of
development.

Complexity: The focus on collaboration and conflict resolution can introduce complexities.

Changing requirements: Continuous changes in requirements can affect project timelines.

Skill requirements: Effective implementation requires skilled project managers and team members.

Scope creep: Without control, the project scope may expand beyond the original plan.

Here's a table outlining the differences between the Spiral Model and the Win-Win Spiral Model:

Spiral Model Win-Win Spiral Model

Requirements negotiation and achieving

Risk management, iterative development,
Focus a mutually beneficial agreement among
and continuous refinement of the software
stakeholders

Objective Manage risks, refine the software through Ensure effective requirements negotiation
iterations, and deliver a high-quality product and reach a mutually satisfactory

unit 1 16
 agreement among stakeholders
Risk analysis, planning, development, and
Process Emphasis evaluation stages throughout the software Requirements negotiation process
development life cycle
Stakeholder involvement is important in risk Stakeholder involvement is critical,
Stakeholder Involvement identification, analysis, and evaluation specifically in requirements negotiation
stages and conflict resolution

❓ Define software. How many types of software are their according to their complexities? (may-
2018) 2-mks

Software refers to the programs, data, and instructions that make computers work and perform tasks. It
includes both the tangible components like code and the intangible components like algorithms and
documentation. It can be divided into three main types:

1. System Software: This is the basic software that manages the computer's hardware and provides a
platform for other software to run. Examples include operating systems like Windows, macOS, and
Linux, as well as device drivers that help devices like printers and scanners work with the computer.

2. Application Software: This is the software that we use for specific tasks or activities. It includes
programs like word processors (e.g., Microsoft Word), spreadsheets (e.g., Microsoft Excel), web
browsers (e.g., Google Chrome), and video games. Some applications are general-purpose and can
be used for many things, while others are specialized for specific purposes.

3. Embedded Software: This software is built into devices and machines to control their functions. It is
found in products like smartphones, digital cameras, home appliances, and car systems. Embedded
software helps these devices work smoothly and perform their specific tasks.

When it comes to complexity, software can be categorized into different levels such as simple, medium,
and complex. This depends on factors like the number of features, the size of the software, and how it
interacts with other systems. However, the complexity levels can vary depending on the specific software
and its purpose.

❓ Explain software engineering as a layered technology. (may-2018)

Software engineering can be thought of as a layered technology, with different levels serving specific
purposes. Here's a simplified explanation:

1. Requirement Layer: This is where the needs and expectations of stakeholders are identified and
defined.

2. Design Layer: A blueprint or plan is created for the software system based on the requirements.

3. Construction Layer: The actual coding and implementation of the software take place.

4. Testing Layer: The software system is tested to ensure it works correctly and meets requirements.

5. Deployment and Maintenance Layer: The software is deployed and maintained in the production
environment.

Each layer builds upon the previous one, creating a structured approach to software development. This
helps ensure that software is developed systematically, meets user needs, and can be maintained

unit 1 17
 effectively.

❓ Explain about the prototype model (2017)

The Prototype Model is a software development approach that involves creating an initial version of the
software to get feedback and make improvements. Here's an explanation:

1. Requirements Gathering: We collect the initial requirements from the people who will use the
software.

2. Prototype Development: We make a basic version of the software, called a prototype, which shows
the main features.

3. Feedback and Evaluation: We show the prototype to the people and ask for their opinions and
suggestions. This helps us make the software better.

4. Making it Better: We use the feedback to improve the prototype. We make changes and add new
things based on what people want.

5. Final Product Development: Once we have made all the improvements, we create the final version of
the software that meets all the requirements.

The Prototype Model helps us understand what people want early on in the process. It allows us to make
changes and improvements based on their feedback. This way, we can create software that people will
like and find useful.

❓ Three “R”-Reuse, Reengineering and Retooling

The three "R"s in software engineering are Reuse, Reengineering, and Retooling. Here's a simplified
explanation:

1. Reuse:
Reuse means using existing software parts or modules when creating new software. Instead of
starting from scratch, we can save time and effort by using components, libraries, or code that have
already been built. Reuse helps us work more efficiently and consistently.

2. Reengineering:
Reengineering is the process of improving existing software systems. We analyze the software, find
areas that need improvement, and make changes to make it better. This could involve fixing bugs,
adding new features, or updating the software to work with the latest technology.

3. Retooling:
Retooling means updating the tools and technologies we use in software development. As technology
advances, we may need to learn new programming languages, use different frameworks, or adopt
new software development tools. Retooling helps us stay up to date and work with the latest and most
effective tools.

These three "R"s—Reuse, Reengineering, and Retooling—are important in software engineering. They
help us work efficiently, improve existing software, and adapt to new technologies.

unit 1 18
 ❓ JAD model

The JAD (Joint Application Development) model is a way of working together in software development.
Here's an explanation:

1. Planning: We decide who needs to be involved and schedule sessions to gather requirements.

2. JAD Sessions: We hold interactive workshops where everyone comes together to discuss and define
requirements. The facilitator helps guide the discussions.

3. Requirements Documentation: We write down all the requirements we discussed in detail. This helps
everyone understand what needs to be done.

4. Feedback and Review: We ask for feedback from stakeholders and users throughout the process.
This helps us improve and make sure we're on the right track.

5. Requirements Sign-Off: Once everyone is satisfied with the requirements, we get their approval by
having them sign off on the final version.

The JAD model encourages collaboration and involvement from all parties. It helps us understand
requirements better and reduces misunderstandings. By working together, we can create software that
meets everyone's needs and expectations.

JAD (Joint Application Development) RAD (Rapid Application Development)

Focuses on working together in workshops to gather

Focuses on quickly delivering a working software system.
requirements and define the system.
Involves all stakeholders to make sure we understand Users are actively involved throughout the development
what the users need. process to provide feedback.

We plan and schedule sessions to gather requirements We break the development into short cycles or sprints,
and make decisions. delivering working parts at each step.
A facilitator helps guide the discussions and make sure Developers and users work closely together to build and
everyone communicates well. test the software.

We document everything to keep a record of what we We focus less on documentation and more on creating
discussed and agreed upon. functional software.
Suitable for projects with complex requirements and Suitable for projects with time constraints and a need for
many people involved. quick iterations.

Both JAD and RAD have their advantages and are used in different scenarios. JAD is useful when
collaboration and understanding requirements are important, while RAD is beneficial for projects with tight
deadlines and a need for quick development.

❓ scrum

Scrum is a project management framework used in software development. Here's an easy explanation of
Scrum:

1. Scrum Team: A Scrum team works together to create software. It includes a Product Owner, Scrum
Master, and Development Team.

2. Product Backlog: The Product Owner makes a list of what needs to be done. It's called the Product
Backlog and has the most important things at the top.

unit 1 19
 3. Sprints: The team works in short bursts of time called Sprints. Each Sprint usually lasts 1-4 weeks.
They choose items from the Product Backlog to work on during the Sprint.

4. Daily Scrum: Every day, the team has a quick meeting called the Daily Scrum. They talk about what
they did yesterday, what they'll do today, and any problems they're facing.

5. Sprint Review: At the end of each Sprint, the team shows what they've done to the stakeholders.
They get feedback and decide what to do next based on that feedback.

6. Sprint Retrospective: After the Sprint Review, the team looks back and talks about what went well and
what could be improved. They make a plan to do better in the next Sprint.

Scrum helps the team work together and improve their software over time. It's flexible and encourages
regular feedback and collaboration.

❓ Extreme programming

Extreme Programming (XP) is a way of developing software that focuses on delivering good-quality
software through these simple ideas:

1. Customer Involvement:
Work closely with the customer to understand their needs and get their feedback throughout the
process.

2. Small Steps:
Break the work into small parts and work on them in short time periods called iterations. Each iteration
produces a working piece of software.

3. Testing All the Time:

Test the software as you go along, not just at the end. This helps catch problems early and makes
sure the software works correctly.

4. Working Together:
Have two programmers work together on the same code. One writes the code while the other checks
it. This helps find and fix mistakes more quickly.

5. Keep It Together:
Regularly combine the work of all the programmers into one central place. This helps catch any
problems that may come up when different pieces of code are put together.

6. A Balanced Pace:
Take care not to overwork. It's important to maintain a good balance between work and personal life
to stay healthy and productive.

By following these principles, Extreme Programming aims to create software that meets the customer's
needs and is of high quality.

❓ Describe verification and validation

Verification and validation are two critical components of software engineering that are used to ensure the
quality of software products. Both are essential in the software development process, but they have

unit 1 20
 different purposes and focus on different aspects of software quality. Below is a brief explanation of
verification and validation:

1. Verification:
Verification is the process of checking whether the software meets the specified requirements and
specifications. It involves ensuring that the software is designed, coded, and integrated correctly and
that it meets the intended purpose. Verification is typically done during the development phase and
focuses on the internal consistency of the software.

2. Validation:
Validation is the process of checking whether the software meets the customer's needs and
requirements. It involves ensuring that the software does what it is supposed to do and that it meets
the customer's expectations. Validation is typically done during the testing phase and focuses on the
external behavior of the software.

3. Differences between verification and validation:

Verification is concerned with ensuring that the software is built correctly, while validation is
concerned with ensuring that the right software is built.

Verification focuses on internal consistency, while validation focuses on external behavior.

Verification is typically done during the development phase, while validation is typically done
during the testing phase.

4. Importance of verification and validation:

Verification and validation are essential for ensuring the quality of software products. They help to
identify and correct defects, improve software reliability, and increase user satisfaction. By ensuring
that the software meets the requirements and specifications and performs as intended, verification
and validation help to minimize the risk of software failure and reduce costs associated with software
maintenance and support.

5. Techniques for verification and validation:

There are several techniques used for verification and validation, including:

Code reviews

User testing

Unit testing

Integration testing

System testing

Acceptance testing

Performance testing

Overall, verification and validation are critical components of the software development process. By
ensuring that the software is built correctly and meets customer needs and expectations, verification and
validation help to improve software quality, reliability, and usability.

❓ Explain about function and non functional requirement

unit 1 21
 1. Functional Requirements:
Functional requirements specify the features and capabilities that the software system must provide
to its users. Here are some key points about functional requirements:

Functional requirements describe the behavior of the software system under specific conditions.

They are typically expressed in terms of use cases or user stories.

Functional requirements define the inputs, processing, and outputs of the software system.

They are essential for defining the primary purpose of the software system.

Functional requirements can be validated through functional testing.

Examples of functional requirements include:

The system should allow users to create, read, update, and delete records.

The system should be able to generate reports based on user-defined criteria.

The system should be able to send email notifications to users.

The system should provide a search functionality for finding specific items.

2. Non-functional Requirements:
Non-functional requirements describe the qualities or characteristics of the software system that are
not directly related to its functionality. Here are some key points about non-functional requirements:

Non-functional requirements define how well the software system performs its functions and how
it behaves under different conditions.

They are typically expressed in terms of quality attributes, such as performance, reliability,
security, and usability.

Non-functional requirements are essential for defining the overall quality of the software system.

They can be validated through non-functional testing.

Examples of non-functional requirements include:

The system should respond to user requests within 3 seconds.

The system should be available 24/7 with no more than 1 hour of downtime per month.

The system should be able to handle 1000 concurrent users.

The system should be secure and protect user data from unauthorized access.

Overall, both functional and non-functional requirements are important for defining the scope and quality
of a software system. By identifying both the functional capabilities and quality attributes of the system,
software engineers can develop a comprehensive set of requirements that meet the needs and
expectations of stakeholders.

unit 1 22