1.

You are a software consultant in a small architectural firm which is in a dilemma of either to buy an
application package (off-the-shelf package) or to seek for developed software (bespoke application
software). As a software engineer, you have been asked to act as an adviser to the firm. You are
required to:

a. Identify and explain factors for selecting application software prior to purchasing and installing on a
microcomputer system you would consider

b. Outline the advantages or reasons why you would prefer or recommend off-the-shelf packages to
your business organization rather than writing software in-house or bespoke application software.

c. What are the factors limiting the effective use of bespoke application software?

2a. Explicitly describe what you understand by the term software prototyping. Differentiate between
throwaway and evolutionary prototyping

b. Identify and concisely discuss the various steps involved in the process of adopting prototyping
approach of software development

c. As a software developer, state the reasons why you would recommend evolutionary prototyping of
software development to your clients instead of throwaway prototyping

3a. Are you of the opinion that the present method of software engineering allows for the production of
fault-free software? If Yes, concisely describe what a fault-free software connotes?

b. Highlight the procedures to ensure a fault-free software development

c. What do you understand by the term software re-use? State the reasons or benefits why you would
recommend the software re-use in software development process

4a. Explicitly describe what you understand by requirements engineering?

b. State the distinction between the following pairs of software engineering terminologies and give
examples where necessary:

I. Software architecture and software design

II. Functional and non-functional requirements

c. State the guidelines for writing requirements in software development

5a. Your client is confused and wants to know if there is really distinction between verification and
validation of software process objectives. As a software engineer you are required to clear the confusion
by stating the principal objectives of verification and validation of software process if there is any

b. Identify and clearly discuss the various testing stages in software development

c. Differentiate between the following pairs in software engineering:

I. Verification and Validation of software proxess

II. Testing and debugging

6a. Explain in details what you understand by software engineering? Briefly discuss the situation of
software engineering today

b. Identify and concisely expound on the goals of software engineering

ci. Briefly discuss the term software crisis to a software trainee engineer in order for him to avoid clashes
with his clients during software project development, and state the causes of software crisis

II. State how software crisis has manifested itself in the early days of software engineering

ANSWERS

Question 1:

a. Factors for selecting application software prior to purchasing and installing on a microcomputer
system you would consider:

Functionality: The software must meet the functional requirements of the business. It is essential to
ensure that the software provides all the necessary features and functions that the business requires to
operate efficiently.

Compatibility: The software must be compatible with the microcomputer system used by the business. It
is important to ensure that the software is compatible with the operating system, hardware, and other
software applications used by the business.

Ease of use: The software must be easy to use and understand by the business staff. The software must
have a user-friendly interface, be intuitive, and not require extensive training to operate.

Scalability: The software should be able to grow with the business. The software must be able to handle
increased volumes of data, users, and transactions as the business expands.
Support and maintenance: The software vendor must provide adequate support and maintenance
services to ensure that the software continues to function optimally. The vendor must have a reliable
and responsive customer service team to resolve any issues that may arise.

b. Advantages or reasons why you would prefer or recommend off-the-shelf packages to your business
organization rather than writing software in-house or bespoke application software:

Cost-effectiveness: Off-the-shelf packages are generally cheaper than bespoke application software. The
development costs of bespoke software can be high, and the maintenance costs can be ongoing.

Faster deployment: Off-the-shelf packages can be deployed quickly, as they are readily available and do
not require development time.

Lower risk: Off-the-shelf packages have a lower risk of failure or bugs, as they have been developed and
tested by the vendor and used by other businesses.

Support and maintenance: The vendor of off-the-shelf packages provides support and maintenance
services to ensure that the software continues to function optimally. The vendor has a dedicated team
to resolve any issues that may arise.

Industry standard: Off-the-shelf packages are developed based on industry standards and best practices,
ensuring that the software is of high quality and meets the necessary standards.

c. Factors limiting the effective use of bespoke application software:

High development costs: The development costs of bespoke application software can be high, as the
software is developed specifically for the business and requires significant time and resources.

Long development time: Bespoke application software can take a long time to develop, delaying its
deployment and use by the business.

Maintenance and support costs: Bespoke application software requires ongoing maintenance and
support, which can be expensive.

Lack of expertise: Developing bespoke application software requires specialized skills and expertise,
which the business may not have in-house. This may lead to delays in development and deployment of
the software.

Compatibility issues: Bespoke application software may have compatibility issues with other software
applications used by the business, leading to integration challenges.
Question 2:

a. Software prototyping is the process of developing a working model or sample of the software
application to demonstrate its functionality and features to stakeholders. The prototype is a preliminary
version of the software that is developed to test and refine the design of the software. The two main
types of software prototyping are:

Throwaway prototyping: This involves developing a prototype that is not intended to be part of the final
software product. It is used to test and refine the design of the software before developing the final
product.

Evolutionary prototyping: This involves developing a prototype that is intended to be part of the final
software product. The prototype is developed incrementally, with each iteration building on the
previous one until the final product is achieved.

b. The steps involved in the process of adopting prototyping approach of software development are:

Identify the requirements: Identify the software requirements and the key features that are needed in
the software application.

Develop the prototype: Develop a prototype of the software application that includes the key features
and functions identified in step 1.

Test the prototype: Test the prototype to ensure that it meets the requirements and that the key
features and functions are working as expected.

Refine the prototype: Refine the prototype based on feedback from stakeholders, such as end-users,
developers, and project managers.

Repeat steps 3 and 4: Repeat steps 3 and 4 until the prototype meets the requirements and
stakeholders are satisfied.

Develop the final product: Use the refined prototype as a blueprint to develop the final software
product.

Test the final product: Test the final product to ensure that it meets the requirements and that the key
features and functions are working as expected.

Deploy the final product: Deploy the final product to end-users.

c. The reasons why I would recommend evolutionary prototyping of software development to clients
instead of throwaway prototyping are:

Cost-effectiveness: Evolutionary prototyping is more cost-effective than throwaway prototyping as the

prototype is intended to be part of the final product, reducing development costs.

Faster deployment: Evolutionary prototyping enables faster deployment of the software product as the
prototype is developed incrementally, with each iteration building on the previous one.

Better stakeholder engagement: Evolutionary prototyping involves stakeholders in the development

process, enabling them to provide feedback that can be used to refine the prototype and develop a
product that meets their needs.

Better quality assurance: Evolutionary prototyping enables better quality assurance as the prototype is
tested and refined throughout the development process, reducing the risk of defects in the final
product.

Reduced risk: Evolutionary prototyping reduces the risk of developing software that does not meet the
requirements or that does not meet the needs of end-users. The prototype is tested and refined
throughout the development process, ensuring that the final product meets the requirements and the
needs of end-users.

Question 3:

a. No, it is not possible to produce completely fault-free software with the current state of software
engineering. A fault-free software application is one that is completely error-free and functions perfectly
under all possible conditions. However, it is impossible to anticipate and eliminate all possible errors and
exceptions that can occur in a complex software system. Even with rigorous testing and quality control
measures, some errors may still exist in the software.

b. The procedures to ensure fault-free software development include:

Requirements analysis: Conduct a thorough analysis of the software requirements to ensure that they
are complete, accurate, and unambiguous.

Design review: Conduct a design review to ensure that the software design meets the requirements and
is free of design flaws that can lead to errors.
Coding standards: Adhere to coding standards that promote code quality and readability, reduce
complexity, and improve maintainability.

Testing: Perform rigorous testing throughout the development process, including unit testing,
integration testing, and system testing, to ensure that the software functions as expected and meets the
requirements.

Quality control: Implement quality control measures to ensure that the software is free of defects and
conforms to industry standards and best practices.

Maintenance: Regularly maintain and update the software to fix any bugs or errors that are discovered
and to ensure that it continues to function as expected.

c. Software re-use refers to the practice of using existing software components or modules in the
development of new software applications. It involves the integration of pre-existing software
components into a new application rather than developing new components from scratch. The reasons
or benefits of software re-use in the software development process include:

Increased productivity: Software re-use can significantly reduce development time and cost by
leveraging pre-existing components rather than developing new ones from scratch.

Improved quality: Re-used software components have already been tested and proven to be effective,
reducing the risk of errors and defects in the new application.

Reduced complexity: Re-using existing software components can reduce the complexity of the
development process by eliminating the need to develop new components from scratch.

Consistency: Re-using existing software components can promote consistency in software development
by using proven, standardized components that conform to industry standards and best practices.

Faster time-to-market: Software re-use can enable faster time-to-market by reducing development time
and increasing productivity, enabling organizations to bring new software products to market more
quickly.

Question 4:

a. Requirements engineering is the process of eliciting, analyzing, specifying, validating, and managing
the requirements of a software system. It involves understanding and defining the needs and constraints
of stakeholders and translating them into a set of specific, measurable, and achievable requirements
that can be used as a basis for designing, developing, and testing the software system.
b. The distinction between the following pairs of software engineering terminologies are:

I. Software architecture and software design:

Software architecture refers to the overall structure of the software system, including its components,
their interactions, and the constraints and principles that guide their design. Software design, on the
other hand, refers to the detailed design of the individual components of the system, such as modules,
classes, and functions.

Example: The architecture of a building describes the overall structure and layout of the building, while
the design focuses on the details of the individual rooms, furnishings, and decor.

II. Functional and non-functional requirements:

Functional requirements are the specific features and functions that the software system must perform
to satisfy the needs of the stakeholders. Non-functional requirements, on the other hand, are the
quality attributes that the software system must possess, such as performance, reliability, usability, and
security.

Example: A functional requirement for a word processing software application is the ability to save and
load files. A non-functional requirement might be that the software must be able to handle large files
quickly and efficiently.

c. The guidelines for writing requirements in software development include:

Clear and unambiguous: Requirements should be clear, precise, and unambiguous, avoiding any
ambiguity or confusion that may lead to errors or misunderstandings.

Testable: Requirements should be testable, meaning that they should be measurable, verifiable, and
able to be demonstrated through testing.

Complete: Requirements should be complete, meaning that they should cover all of the necessary
features and functions of the software system, as well as any constraints or limitations that may impact
the system.

Consistent: Requirements should be consistent, meaning that they should not contradict each other or
create conflicts that cannot be resolved.
Traceable: Requirements should be traceable, meaning that they should be linked to specific
stakeholders, use cases, or system functions, allowing them to be tracked and managed throughout the
development process.

Prioritized: Requirements should be prioritized, meaning that they should be ranked in order of
importance or urgency, allowing development teams to focus on the most critical features and functions
first.

Question 5:

a. Verification and validation are two distinct processes in software engineering. Verification aims to
ensure that the software meets its specified requirements and that it has been developed in accordance
with the predefined processes and standards. Validation, on the other hand, aims to ensure that the
software meets the needs of its intended users and performs its intended functions correctly.

The principal objective of verification is to detect and eliminate errors or defects in the software
development process before the software is released. The objective of validation is to ensure that the
software meets the user's needs and expectations, and performs its intended functions correctly.

b. The various testing stages in software development include:

Unit testing: This is the testing of individual components or modules of the software to ensure that they
function correctly.

Integration testing: This is the testing of the interaction between different components or modules of
the software to ensure that they work together correctly.

System testing: This is the testing of the entire software system to ensure that it meets its functional and
non-functional requirements.

Acceptance testing: This is the testing of the software by the end-users or stakeholders to ensure that it
meets their needs and expectations.

c. The distinction between the following pairs in software engineering are:

I. Verification and Validation of software process:

Verification refers to the process of evaluating the software development process to ensure that it
follows the defined processes and standards and meets its specified requirements. Validation refers to
the process of evaluating the software product to ensure that it meets the user's needs and
expectations and performs its intended functions correctly.

II. Testing and debugging:

Testing refers to the process of evaluating the software to ensure that it meets its specified
requirements and that it performs its intended functions correctly. Debugging refers to the process of
identifying, analyzing, and fixing errors or defects in the software code or design. Testing aims to detect
and prevent errors, while debugging aims to locate and fix errors that have already occurred.

Question 6:

a. Software engineering is the application of engineering principles to the design, development, testing,
and maintenance of software. It is a discipline that aims to improve the quality, reliability, and efficiency
of software systems. Software engineering involves the use of various methodologies, tools, and
techniques to ensure that software systems meet their functional and non-functional requirements.

The situation of software engineering today is characterized by the growing demand for software
systems in various domains, such as finance, healthcare, entertainment, and transportation. This
demand has led to an increase in the complexity and size of software systems, which poses challenges to
software engineers in terms of managing the development process, ensuring quality, and meeting user
requirements.

b. The goals of software engineering include:

To develop high-quality software systems that meet their functional and non-functional requirements.

To improve the efficiency and productivity of the software development process.

To reduce the time and cost of developing software systems.

To ensure that software systems are maintainable and scalable.

To ensure that software systems are secure and reliable.

c. The term software crisis refers to the difficulties that arise in the development and maintenance of
software systems. These difficulties include cost overruns, schedule delays, low quality, and difficulty in
meeting user requirements. Software crisis is caused by various factors, including:
Complexity: Software systems are becoming increasingly complex, which makes them difficult to
develop, test, and maintain.

Changing requirements: User requirements often change during the software development process,
which can lead to scope creep, schedule delays, and cost overruns.

Lack of standardization: Software development processes and tools are not standardized, which can lead
to inconsistencies and errors in the development process.

Inadequate testing: Software systems are often not tested adequately, which can lead to defects and
errors in the software.

d. Software crisis manifested itself in the early days of software engineering through the following ways:

Cost overruns: Many software projects exceeded their budgets, which led to financial losses for the
organizations involved.

Schedule delays: Many software projects took longer than expected to complete, which resulted in
delays in the delivery of the software.

Low quality: Many software systems were of poor quality, which led to defects, errors, and failures.

Difficulty in meeting user requirements: Many software systems did not meet the needs and
expectations of their intended users, which led to user dissatisfaction and rejection of the software.