QUESTION ONE

a) Ethics of Testing Until Budget

Exhaustion and Delivering to Customers
(5 marks)
This approach raises ethical concerns in
software engineering:
1. Quality Compromise: Testing until
the budget runs out prioritizes cost over
quality, potentially delivering a system
with undetected critical defects, risking
user safety or data security.
2. Lack of Accountability: It
undermines responsibility to deliver a
reliable product, as the focus is on
financial limits rather than ensuring the
system meets functional and safety
standards.
3. User Trust Violation: Customers
expect a thoroughly tested system.
 Delivering an inadequately tested
product can erode trust, especially if
failures occur in critical applications
(e.g., healthcare).
4. Legal and Financial Risks: If
defects cause harm, the organization
could face lawsuits or financial losses,
reflecting poorly on ethical standards.
5. Professional Integrity: Software
engineers are bound by ethical codes
(e.g., ACM Code of Ethics) to prioritize
public good, which this approach
neglects by valuing budget over quality.
Ethically, testing should aim for adequate
coverage and reliability, not just budget
exhaustion, to ensure user safety and
satisfaction.
b) Manager’s Reaction to a Programmer
Ignoring Quality Standards (5 marks)
The programmer’s behavior, despite low
defects, requires a strategic response:
1. Address the Issue Directly:
Managers should have a one-on-one
discussion to understand why she
ignores standards, emphasizing their
importance for team consistency and
long-term maintainability.
2. Reinforce Training: Provide training
or workshops on the organization’s
quality standards, showing how
adherence improves collaboration and
reduces future technical debt.
3. Set Clear Expectations: Update her
performance goals to include
compliance with standards, making it a
measurable part of her evaluation.
 4. Implement Code Reviews: Enforce
peer reviews to ensure her work aligns
with standards, fostering accountability
and team alignment.
5. Balance Recognition and
Correction: Acknowledge her skill in
producing low-defect code, but stress
that ignoring standards risks scalability,
interoperability, and team efficiency,
requiring corrective action.
Ignoring standards can lead to inconsistent
codebases, making maintenance harder, so
managers must act to align her practices
with organizational goals.

c) Five Benefits of Component-Based

Software Engineering (CBSE) (5 marks)
1. Reusability: Components are
designed to be reused across projects,
 reducing development time and effort
(e.g., using a payment module in
multiple apps).
2. Faster Development: Pre-built
components allow developers to
assemble systems quickly rather than
building from scratch, speeding up
delivery.
3. Cost Efficiency: Reusing
components lowers development costs
by minimizing redundant coding and
testing efforts.
4. Scalability: Components can be
independently updated or replaced,
making it easier to scale or modify
systems without affecting the whole
application.
5. Improved Maintainability: Modular
design means issues can be isolated
 and fixed in specific components,
simplifying maintenance and
debugging.
CBSE enhances efficiency and flexibility in
software development by promoting
modularity and reuse.

d) Five Circumstances to Recommend

Against Software Reuse (5 marks)
1. High Customization Needs: If the
software requires highly specific
functionality that existing components
can’t meet, reuse may lead to extensive
modifications, negating benefits.
2. Incompatible Technologies:
Reusing components built for different
platforms or languages (e.g., a Java
component in a Python project) can
 cause integration issues and
inefficiencies.
3. Poor Component Quality: If
reusable components are poorly
documented, untested, or have known
defects, they can introduce risks and
reduce system reliability.
4. Licensing Restrictions:
Components with restrictive licenses
(e.g., GPL) may impose legal or
distribution constraints, making reuse
impractical.
5. Performance Overheads: Reused
components may include unnecessary
features, leading to bloat and reduced
performance in resource-constrained
systems (e.g., embedded systems).
Reuse should be avoided when it
compromises quality, compatibility, or
project goals.

e) Two Pros and Two Cons of IoT in

Society (4 marks)
Pros:
1. Efficiency and Automation: IoT
devices, like smart thermostats,
optimize energy use, saving costs and
reducing environmental impact.
2. Improved Healthcare: IoT
wearables (e.g., fitness trackers)
monitor health in real-time, enabling
early detection of issues and better
patient care.
Cons:
1. Security Risks: IoT devices are often
vulnerable to hacking (e.g., smart
 cameras), risking privacy breaches and
data theft.
2. Complexity and Cost:
Implementing and maintaining IoT
systems requires significant investment
and technical expertise, which can be a
barrier for widespread adoption.
IoT offers transformative benefits but
introduces significant challenges in
security and implementation.

f) Six Practices for Successful

Collaboration in Software Engineering (6
marks)
1. Clear Communication: Use tools
like Slack or Microsoft Teams to ensure
transparent, regular communication,
reducing misunderstandings on project
goals.
2. Version Control Systems: Adopt
tools like Git to manage code changes,
enabling seamless collaboration and
tracking of contributions across teams.
3. Agile Methodologies: Implement
Agile practices (e.g., daily stand-ups,
sprints) to foster teamwork,
adaptability, and continuous feedback.
4. Defined Roles and
Responsibilities: Clearly assign tasks
and roles to avoid overlap, ensuring
team members know their contributions
(e.g., using Jira for task tracking).
5. Code Reviews and Pair
Programming: Encourage peer reviews
and pair programming to share
knowledge, catch errors early, and
improve code quality collaboratively.
 6. Shared Documentation: Maintain
up-to-date documentation (e.g., via
Confluence) to ensure all team
members have access to project
requirements, designs, and decisions.
These practices enhance teamwork, reduce
errors, and ensure efficient project delivery
in software engineering.
QUESTION TWO
a) Define Deep Learning and Describe Its
Current and Future Uses (5 marks)
Definition: Deep learning is a subset of
machine learning that uses neural networks
with multiple layers (deep neural networks)
to analyze and learn from large amounts of
data. It excels at identifying patterns in
unstructured data like images, audio, and
text by automatically extracting features
without manual intervention.
Current Uses:
1. Image Recognition: Deep learning
powers facial recognition in security
systems (e.g., Apple Face ID) and
medical imaging for diagnosing
diseases like cancer.
2. Natural Language Processing
(NLP): It drives chatbots (e.g., ChatGPT)
and voice assistants (e.g., Alexa) for
understanding and generating human
language.
Future Uses:
1. Autonomous Vehicles: Deep
learning could enhance real-time
decision-making for self-driving cars,
improving object detection and
navigation in complex environments.
2. Personalized Medicine: It might
analyze genetic data to predict disease
 risks and tailor treatments for
individuals, advancing precision
healthcare.
Deep learning’s ability to handle complex
data makes it transformative across
industries.

b) How Big Data Assists Business

Intelligence (BI) in Decision-Making (6
marks)
Companies using BI already collect data for
analysis, and Big Data enhances this
process in the following ways:
1. Volume Handling: Big Data
technologies (e.g., Hadoop, Spark)
manage massive datasets (terabytes or
petabytes) that traditional BI tools can’t
process, enabling deeper insights.
2. Variety of Data: Big Data
incorporates unstructured data (e.g.,
social media posts, videos) alongside
structured data, giving BI a broader view
for decision-making.
3. Velocity for Real-Time Analysis: Big
Data tools process data streams in real-
time (e.g., IoT sensor data), allowing BI
to provide up-to-date insights for
immediate actions, like dynamic
pricing.
4. Advanced Analytics: Big Data
enables predictive analytics and
machine learning within BI, helping
companies forecast trends (e.g.,
customer behavior) more accurately.
5. Scalability: Big Data infrastructure
scales easily, ensuring BI systems can
 handle growing data needs without
performance drops.
6. Cost Efficiency: Cloud-based Big
Data solutions (e.g., AWS Redshift)
reduce storage and processing costs,
making BI more accessible for data-
driven decisions.
Big Data empowers BI by providing richer,
faster, and more scalable data analysis for
better decision-making.

c) Role of Software Ecosystems in

Software Engineering (5 marks)
Software ecosystems are networks of
interconnected software components,
developers, and organizations that
collaboratively build, share, and use
software. Their role in software engineering
includes:
1. Component Reuse: Ecosystems
like npm or Maven provide libraries and
frameworks, allowing engineers to reuse
code (e.g., React for UI development),
speeding up development.
2. Interoperability: They enable
software to work seamlessly with other
systems (e.g., Android ecosystem apps
integrating with Google services),
enhancing functionality.
3. Community Collaboration:
Ecosystems foster open-source
contributions (e.g., GitHub), where
developers share tools, fix bugs, and
improve software collectively.
4. Innovation Acceleration: They
provide platforms (e.g., Apple’s iOS
ecosystem) for developers to build and
 distribute apps, driving innovation
through competition and collaboration.
5. Standardization: Ecosystems
establish standards (e.g., APIs in the
Java ecosystem), ensuring consistency,
reducing compatibility issues, and
simplifying development.
Software ecosystems enhance efficiency,
collaboration, and innovation in software
engineering.

d) Four Challenges of Implementing

Software Process Technology (4 marks)
Software process technology involves tools
and methods to automate and improve
software development processes.
Challenges include:
1. Resistance to Change: Developers
may resist adopting new tools or
 processes (e.g., shifting to Agile tools
like Jira), preferring familiar workflows,
which slows implementation.
2. High Initial Costs: Implementing
tools like CI/CD pipelines (e.g., Jenkins)
requires investment in infrastructure,
training, and licensing, which can strain
budgets.
3. Integration Complexity: Integrating
process tools with existing systems
(e.g., legacy codebases) can be
technically challenging, leading to
compatibility issues and delays.
4. Skill Gaps: Teams may lack the
expertise to use advanced process
technologies (e.g., automated testing
frameworks), requiring extensive
training and slowing adoption.
These challenges can hinder the effective
adoption of software process technology,
impacting productivity.
QUESTION THREE
a) Elements of a Software Process
Improvement (SPI) Framework (7 marks)
A Software Process Improvement
framework aims to enhance the quality,
efficiency, and effectiveness of software
development processes. A common
framework like the Capability Maturity
Model Integration (CMMI) or IDEAL model
can be used to describe its elements.
Here’s an explanation with a simplified
diagram:
Elements of an SPI Framework (IDEAL
Model):
1. Initiating: Identify the need for
improvement, set goals, and gain
 stakeholder commitment. This involves
assessing current processes and
defining the scope of SPI.
2. Diagnosing: Analyze existing
processes to identify weaknesses (e.g.,
using process audits or metrics) and
determine areas for improvement.
3. Establishing: Plan the improvement
strategy, set priorities, and define
actionable steps, including selecting
tools, methods, or standards to adopt.
4. Acting: Implement the improvement
plan, such as adopting new tools (e.g.,
CI/CD pipelines) or training teams on
Agile practices.
5. Learning: Evaluate the outcomes of
the changes, gather feedback, and
refine processes for continuous
 improvement, ensuring lessons are
applied to future cycles.
Diagram (Text-Based Representation):
[Initiating] --> [Diagnosing] -->
[Establishing] --> [Acting] --> [Learning]
(Set Goals) (Assess Gaps) (Plan
Changes) (Implement) (Evaluate & Refine)
^---------------------------------------------------
--------------|
(Continuous Improvement Loop)
This cyclic framework ensures systematic,
iterative improvement, aligning processes
with organizational goals and enhancing
software quality.

b) Is SPI Suitable for a Small Software

Organization with 11 People? (5 marks)
Software Process Improvement (SPI) can be
beneficial for a small organization, but its
applicability depends on context:
1. Yes, SPI Can Be Suitable:
o Improved Efficiency: Even small
teams can benefit from streamlined
processes (e.g., adopting Agile or
basic CI/CD), reducing waste and
improving delivery speed.
o Scalability: SPI helps establish good
practices early, preparing the
organization for growth (e.g.,
standardizing code reviews for
consistency).
o Lightweight Approach: Small teams
can adopt a tailored, lightweight SPI
framework (e.g., focusing on a few
key processes) without
overwhelming resources.
 2. Challenges to Consider:
o Resource Constraints: With only 11
people, dedicating time and effort to
SPI might strain development work,
as there’s little room for overhead.
o Cost vs. Benefit: Formal SPI
frameworks like CMMI can be
expensive and complex, potentially
offering limited immediate value for
a small team.
Conclusion: SPI is suitable if implemented
pragmatically, focusing on high-impact,
low-effort improvements (e.g., basic
automation or Agile practices) that align
with the team’s size and goals, rather than
adopting a heavy formal framework.
c) Ideal Online Tool Set for Collaborative
Editing of a 245-Page Requirements
Specification (3 marks)
For a global team across Los Angeles,
London, Mumbai, Hong Kong, and Sydney
to collaboratively edit a 245-page
requirements specification in three days,
the ideal online tool set includes:
1. Google Docs: A cloud-based
document editor for real-time
collaborative editing, allowing all team
members to work on the specification
simultaneously.
2. Slack: A communication platform
for instant messaging, file sharing, and
team coordination, ensuring quick
resolution of questions across time
zones.
 3. Trello: A project management tool to
assign sections of the document to
team members, track progress, and
ensure the editing is completed within
three days.
This tool set enables seamless
collaboration, communication, and task
management despite the geographical
spread and tight deadline.

d) Five Features of the Tool Set in (c) (5

marks)
Focusing on the primary tool, Google Docs,
here are five key features that enable
effective collaboration:
1. Real-Time Editing: Multiple users
can edit the document simultaneously,
with changes visible instantly, ensuring
 efficient collaboration across time
zones.
2. Commenting and Suggestions:
Team members can add comments or
suggest edits without altering the
original text, facilitating discussion and
feedback (e.g., clarifying requirements).
3. Version History: Tracks all changes
with timestamps and user details,
allowing the team to revert to previous
versions if needed, ensuring no work is
lost.
4. Access Control: Permissions can be
set to control who can view, edit, or
comment, ensuring security and role-
based access for the global team.
5. Cloud-Based Accessibility: As a
cloud tool, it’s accessible from
anywhere with an internet connection,
 enabling the team in different cities to
work seamlessly.
These features make Google Docs ideal for
collaborative, time-sensitive editing of a
large requirements specification.
QUESTION FOUR
a) Test-Driven Development (TDD)
Process Flow with Diagram (7 marks)
Test-Driven Development (TDD) is a
software development approach where
tests are written before the code, ensuring
that the code meets requirements
incrementally. The process follows a
repetitive cycle.
TDD Process Flow:
1. Write a Test: Create a failing test
case for a small piece of functionality
(e.g., a function to add two numbers).
 2. Run the Test: Execute the test; it
fails because the functionality isn’t
implemented yet (red phase).
3. Write Code: Write the minimal code
needed to pass the test (e.g., implement
the addition function).
4. Run the Test Again: Execute the
test; it should now pass (green phase).
5. Refactor: Improve the code for
readability, efficiency, or maintainability
while ensuring all tests still pass.
6. Repeat: Move to the next piece of
functionality, repeating the cycle.
Diagram (Text-Based Representation):
[Write Test] --> [Run Test (Fail)] --> [Write
Code] --> [Run Test (Pass)] --> [Refactor] -->
[Repeat]
(Red) (Red Phase) (Implement)
(Green Phase) (Optimize) (Next Cycle)
 ^------------------------------------------------
--------------------|
(Iterative Loop)
This cycle ensures code is reliable, meets
requirements, and remains maintainable,
as tests drive development and catch
issues early.

b) Five Reasons Why Open-World

Software Challenges Conventional
Software Engineering (5 marks)
Open-world software operates in dynamic,
unpredictable environments (e.g., IoT
systems, autonomous vehicles), unlike
conventional software with defined
boundaries. Challenges include:
1. Unpredictable Inputs: Open-world
systems face diverse, real-time inputs
(e.g., sensor data), which are hard to
 anticipate, unlike conventional systems
with controlled inputs.
2. Evolving Requirements: The
environment changes constantly (e.g.,
new devices in IoT), requiring frequent
updates, whereas conventional
approaches assume stable
requirements.
3. Scalability Issues: Open-world
software must scale dynamically (e.g.,
millions of connected devices),
challenging conventional methods that
focus on fixed-scale systems.
4. Security Risks: Exposure to
external, unpredictable interactions
increases vulnerabilities (e.g., hacking
IoT devices), unlike conventional
software with clearer security
boundaries.
 5. Testing Complexity: It’s difficult to
simulate all possible scenarios in an
open-world context, whereas
conventional software can be tested in
controlled environments.
These factors make open-world software
harder to design, test, and maintain using
traditional methods.

c) What Are Emergent Requirements? (2

marks)
Emergent requirements are requirements
that arise unexpectedly during the
development or operation of a software
system, often due to changes in the
environment, user needs, or system
interactions. They are not identified during
the initial requirements analysis (e.g., a new
security feature needed after a cyberattack
emerges mid-project).

d) Six Reasons Why Emergent

Requirements Challenge Software
Engineers (6 marks)
1. Scope Creep: Emergent
requirements can expand the project
scope, delaying timelines and
increasing costs (e.g., adding a new
feature mid-development).
2. Design Incompatibility: The existing
system architecture may not support
new requirements, requiring significant
rework (e.g., a new UI feature clashing
with the current design).
3. Resource Constraints: Addressing
emergent requirements often demands
 additional time, budget, or personnel,
which may not be available mid-project.
4. Testing Overhead: New
requirements necessitate additional
testing, potentially invalidating prior
tests and increasing the risk of defects
(e.g., regression issues).
5. Stakeholder Conflicts: Emergent
requirements may lead to
disagreements among stakeholders
about priorities, complicating decision-
making (e.g., users vs. developers on
feature importance).
6. Documentation Updates: The team
must revise requirements, design, and
user documentation to reflect the
changes, adding to the workload and
risking inconsistencies.
Emergent requirements disrupt planning
and development, making adaptability and
flexible processes critical for software
engineers.

Services in Cloud Computing

Cloud computing provides on-demand
access to computing resources over the
internet, categorized into several key
service models:
1. Infrastructure as a Service (IaaS):
Offers virtualized computing resources
like servers, storage, and networking.
Users can scale infrastructure as
needed without managing physical
hardware. Examples: Amazon EC2,
Google Compute Engine, Microsoft
Azure VMs. Use case: Hosting
applications with flexible scaling.
2. Platform as a Service (PaaS):
Provides a platform for developing,
testing, and deploying applications
without managing underlying
infrastructure (e.g., servers, databases).
Examples: Google App Engine, Heroku,
Microsoft Azure App Services. Use case:
Streamlining app development with pre-
configured environments.
3. Software as a Service (SaaS):
Delivers software applications over the
internet on a subscription basis,
managed by the provider. Examples:
Gmail, Microsoft 365, Salesforce. Use
case: Accessing tools like email or CRM
without local installation.
4. Function as a Service (FaaS):
Enables serverless computing, where
developers run code in response to
events without managing servers.
 Examples: AWS Lambda, Google Cloud
Functions, Azure Functions. Use case:
Running event-driven tasks like
processing uploads.
5. Storage as a Service: Provides
scalable storage solutions for data
backup, archiving, or sharing.
Examples: Amazon S3, Google Cloud
Storage, Dropbox. Use case: Storing
large datasets securely.
6. Database as a Service (DBaaS):
Offers managed database solutions,
handling maintenance and scaling.
Examples: Amazon RDS, Google Cloud
SQL, MongoDB Atlas. Use case:
Managing relational or NoSQL
databases.
7. Container as a Service (CaaS):
Facilitates containerized application
 deployment and management using
tools like Docker or Kubernetes.
Examples: Google Kubernetes Engine
(GKE), AWS ECS. Use case: Running
microservices efficiently.
DevOps is a set of practices that combines
software development (Dev) and IT
operations (Ops) to improve collaboration,
automate processes, and accelerate the
delivery of high-quality software. It
emphasizes continuous integration,
continuous delivery (CI/CD), infrastructure
as code (IaC), and monitoring to streamline
workflows.
For example, in a DevOps pipeline,
developers commit code to a shared
repository, automated tests run via CI tools
like Jenkins, and the code is deployed to
production using CD tools like GitLab. This
reduces manual errors, speeds up
releases, and ensures scalability, as seen in
platforms like AWS using IaC tools such as
Terraform. DevOps fosters a culture of
shared responsibility, enhancing efficiency
in software engineering.

Emerging Challenges in AI and Machine

Learning
1. Data Quality and Scarcity: AI/ML
models require large, high-quality
datasets. However, obtaining clean,
unbiased, and diverse data is
challenging, especially for niche
domains like rare diseases or low-
resource languages. Poor data leads to
inaccurate models and perpetuates
biases.
2. Bias and Fairness: Models often
inherit biases from training data, leading
 to unfair outcomes (e.g., biased hiring
algorithms). Addressing this requires
better bias detection, mitigation
techniques, and diverse dataset
representation, which is complex and
resource-intensive.
3. Explainability and Transparency:
Many AI models, especially deep
learning ones, are "black boxes," making
it hard to understand their decisions.
This lack of interpretability is a
challenge in critical areas like
healthcare or finance, where trust and
accountability are essential.
4. Scalability and Efficiency: As
models grow larger (e.g., LLMs like GPT),
they demand more computational
resources, increasing costs and energy
consumption. Optimizing models for
 efficiency without sacrificing
performance is a growing challenge.
5. Security and Adversarial Attacks:
AI systems are vulnerable to adversarial
attacks, where small, intentional
changes to inputs (e.g., slightly altered
images) can fool models. Ensuring
robustness against such attacks, as well
as protecting models from data
poisoning, is critical.
6. Ethical and Regulatory Concerns:
The rapid deployment of AI raises
ethical issues like privacy violations, job
displacement, and misuse (e.g.,
deepfakes). Governments are
introducing regulations (e.g., EU AI Act),
but aligning innovation with compliance
is challenging.
7. Generalization and Overfitting:
Models often struggle to generalize to
new, unseen data, especially in
dynamic environments. Few-shot and
zero-shot learning aim to address this,
but achieving robust generalization
across domains remains difficult.
8. Environmental Impact: Training
large AI models consumes significant
energy, contributing to carbon
emissions. Developing sustainable AI
practices, like energy-efficient
algorithms or green computing, is an
emerging challenge.