Software Development – Final Examination

Duration: 3 Hours
Total Marks: 100
Section A: Core Concepts (30 Marks)
Answer all questions.

ANSWERS
1. Compare Agile and traditional (Waterfall) methodologies in terms of:
Requirement handling (e.g., fixed vs. evolving). (3 Marks)
Documentation intensity (e.g., MRDs vs. user stories). (3 Marks)
Suitability for projects with unclear initial requirements. (4 Marks)
A. Requirement handling
Waterfall follows a linear, sequential approach where requirements are
fixed at the start. Changes are difficult to accommodate once the project
progresses (eg after the design phase), ex. Building a bridge

Agile embraces evolving requirements through iterative development.

Requirements are refined continuously based on user feedback and changing
business needs. Eg a mobile app where new features are added based on
user demands

B. Documentation intensity
In waterfall method there is heavy documentation. Detailed design docs, test
plans and sign-offs are mandatory before coding begins

In agile, there is lightweight documentation. Focus on working software over

comprehensive documentation (following the agile manifesto principle)

C. Suitability for projects with unclear initial requirements

 Waterfall is unsuitable because all requirements are known upfront hence
difficult for innovative projects. Changes require costly rework.

Agile is highly suitable: iterative cycles allow refinement of requirements.

Good for projects where needs evolve

2. Requirement Engineering (8 Marks)

a. Explain MoSCoW prioritization with an example from the lecture notes. (4
Marks)
MoSCoW method categorizes requirements into;
- Must have (critical, non-negotiable) eg secure payment gateway in an e
commerce platform.
- Should have (important but not vital) eg production recommendation
engine (ecom)
- Could have (nice to have, low priority) eg dark mode
- Won’t have (deffered or out of scope) eg augmented reality

b. Why is competitive analysis critical during requirement gathering? (4 Marks)

- Identifies industry standards eg users expect one-clcik checkout like
amazon)
- Uncovers gaps in competitors product
- Helps define unique selling points for software

3. Testing & Quality Assurance (6 Marks)

a. Differentiate unit testing, regression testing, and UAT using examples. (3
Marks)
Unit testing Regression testing User acceptance T
Test individual Ensure new code Validates software
modules/functions doesn’t break meets business needs
existing features
Testing a calcTax Re-running tests after End-users testing an
function a login bug fix e-commerce
checkout flow
 b. How does test automation align with Agile principles? (3 Marks)
Agile emphasizes continuous delivery, requiring
- Fast feedback: automated tests (eg CI/CD (continuous integration,
continuous delivery) pipelines) on every commit
- Reduced manual effort: frees developers for high-value tasks

4. Version Control & Collaboration (6 Marks)

a. Describe branching strategies for software releases (e.g., bugfix branches). (3
Marks)
- Main/master: stable production code.
- Feature branches: isolate new features
- Bugfix branches: hotfixes for production issues
- Relaease branches: prep for devolopment
b. Name two tools for collaboration in distributed teams and justify their use. (3
Marks)
- Slack; real time chat, integrations (Jira, Github). Reduces email clutter and
speeds up0 decisions
- GitHub/GitLab; code reviews, issues, CI/CD. Ensures version control and
team transparency

Questions For Revision

Group 1.
Q1. Identify and describe the different types of stakeholders involved in eliciting
requirements for a software development project. Provide examples for each
type.
1. Primary stakeholders (direct users)
Those who directly interact with the sytem. Eg end users, system admins
who maintain the software
2. Secondary stakeholders (indirectly affected)
Those impacted by the system but don’t use it directly. Eg marketing teams
 a. Technical stakeholders (external influencers)
Developers, testers and IT staff who build and maintain the project. Eg swe
engs working on the backend
3. Business stakeholders
People who fund the project and define business goals
4. Regulatory stakeholders
External entities that impose compliance requirements

Q2. What are user personas, and how do they impact the requirement gathering
process? Provide two ways in which personas help in prioritizing requirements
based on business value.
User Personas are fictional, representations of key user groups, created
based on research and data. They include details like demographics, goals and
pain points.
Requirement gathering:
- Personas help teams empathize with users, ensuring requirements align
with needs.
- They prevent bias by focusing on evidence-based user behavious rather
than assumptions
Priotization based on business value
- High-impact personas: requirements for personas representing the
largest or most profitable user segments are prioritized. Eg prioritizing
features for frequent users over occasional users
- Pain point resolution: personas highlight critical pain points, allowing
teams to prioritize fixes that enhance user retentions or satisfaction. Eg
fixing slow load times for elderly users who value simplicity and speed

Q3. How does the use of feature prioritization models (e.g., MoSCoW, Kano)
influence stakeholder satisfaction and project success?
- Must have (critical, non-negotiable) eg secure payment gateway in an e
commerce platform.
 - Should have (important but not vital) eg production recommendation
engine (ecom)
- Could have (nice to have, low priority) eg dark mode
- Won’t have (deffered or out of scope) eg augmented reality

Group Two
1. What are the primary functions that the system or product needs to perform?
Primary functions are the core operations the sytem must execute to meet
user/business goals. Examples: the core functions, support functions,
administrative functions.

2. How will the system or product handle user input and interactions?
The system should:
Validate inputs: ensure data correctness (eg email format checks, syntactic
and sementic rules are followed)
Provide feedback: confirm actions (eg “Order placed successfully”)
Handle errors gracefully: Offer suggestions (eg did u mean x?), clear error
messages

3. What are the specific requirements for data processing, storage, and retrieval
in the system or product?
Processing: rules for transforming data (eg calculating discounts in real
time)
Storage: database design
Retieval: Efficient querying

Group 3
1) What role does emergent design play in agile architecture, and how can teams
effectively implement it in their development processes?
 Emergent design is the practice of evolving a system’s architecture
incrementally, based on feedback and changing requirements, rather than
upfront planning.
Implementation
- Refactoring: Continuously improve code to adapt to new needs
- Spike solutions: prototype risky features early to validate design choices
- YAGNI (You Ain’t Gon Need It): avoid over-engineering by adding
features only when necessary.
2) what tools are commonly used for creating and managing architecture
documents.
- Diagramming: Lucidchart, Draw.io
- Documentation: Confluence, Notion
- Collaboration: Miro, Structurizr
- Version control: Git

3) how can teams balance the need for thorough design documentation with the
agile principles of rapid iteration and flexibility
- Just-in-time Documentation: document only when a feature is about to be
developed
- Living documents: use wikis for easy updates
- Lightweight Artifacts: Replace lengthy specs with user stories and
annotated diagrams

Group 4
1)What is technical debt and how can it affect future software development
efforts
Technical debt is the implied cost of taking shortcuts (eg rushed code, lack
of tests) that slow future development. Impacts;
- Increased bugs as poor code leads to more defects
- Slower progress
- Higher costs
 2) Describe three challenges that developers might face during
implementation and coding
- Legacy code integration; merging new features with outdated, poorly
documented systems
- Dependency conflicts: incompatible library versions
- Concurrency issues: Race conditions in multi-threaded environments

3)Suggest one best practice to overcome each of these challenges

- Legacy code: write wrapper APIs to isolate and gradually replace legacy
components.
- Dependencies: use virtual environments or dependency managers
- Concurrency: implement locking mechanisms or use atomic operations
Group 5
1. What is the main purpose of Testing and Quality Assurance in Agile projects?
The primary purpose in agile is to ensure that the software meets business
and user requiremnts while maintaining high quality throughout rapid
development cycles. Key objections include:
- Early bug detection: identifying defects warly to reduce fixing costs
- Continuous feedback; immediate insights to improve code
- User satisfaction
- Risk mitigation

2. Name two Agile testing methodologies and briefly explain them and give real
life examples.
a. Behavior-Driven Development (BDD):
Definition: Collaboration between developers, testers, and non-technical
stakeholders to define tests in natural language (e.g., Gherkin syntax).
Example: A team building an e-commerce app writes scenarios like:
Given a user has items in their cart
When they click "Checkout"
 Then they should see payment options.
Tools: Cucumber, SpecFlow.
b. Exploratory Testing:
Definition: Unscripted testing where testers dynamically explore the system
to uncover unexpected issues.
Example: A tester interacts with a new social media feature, trying
edge cases like uploading malformed images or spamming buttons.
Tools: Session-based test management tools like TestRail.

3. What is one common challenge faced in Testing and Quality Assurance, and
how can it be addressed?
Challenge: Test Coverage Gaps – Critical scenarios are missed due to time
constraints or unclear requirements.
Solution:
Risk-Based Testing: Prioritize tests for high-impact areas (e.g., payment
processing).
Automation: Use tools like Selenium or JUnit to cover repetitive test cases.
Collaboration: Involve QA early in sprint planning to align tests with user stories.
Example: A team uses a risk matrix to focus testing on login security and checkout
flows in an e-commerce app.

Group 6
1. What are the key components of release planning in Agile, and how do sprint
reviews and release burndown charts support this process?
Key Components:
• Release Goals: Business objectives (e.g., "Launch MVP by Q3").
• Feature Backlog: Prioritized list of functionalities.
• Timeline: Iterative delivery dates (aligned with sprints).
 • Dependencies: External integrations or team constraints.
Sprint Reviews: Demo completed work to stakeholders for feedback, ensuring the
release aligns with expectations.
Release Burndown Charts: Track remaining work (e.g., story points) against time,
visualizing progress and predicting release readiness.
Example: A burndown chart showing 80% of features completed by Sprint 5,
prompting a go/no-go decision

2. How can feature toggles and versioning strategies help manage software
releases effectively?
• Feature Toggles (Flags):
o Enable/disable features dynamically without redeploying code.
o Example: Rolling out a beta "Dark Mode" to 10% of users via a toggle.
• Versioning Strategies:
o Semantic Versioning (SemVer): Communicate changes
(e.g., MAJOR.MINOR.PATCH).
o Example: Bumping to v2.0.0 for a breaking API change.
Benefits:
• Reduce risk by gradually releasing features.
• Support A/B testing and rollback capabilities.

3. Why is User Acceptance Testing (UAT) important before a software release, and
how does it fit into Agile model.
UAT Importance:
• Validates that the system meets real-world user needs.
• Uncovers usability issues missed in dev/testing (e.g., confusing workflows).
Agile Fit:
 • Conducted during the final sprint(s) with actual users or proxies (e.g.,
Product Owner).
• Feedback loops into the backlog for iterative improvements.
Example: A banking app’s UAT reveals that small businesses struggle with
bulk transfers, prompting a redesign.

Group 7
1)What is the goal of Agile documentation principles?
Answer:
To provide just enough documentation to support development and maintenance
without hindering agility. Goals include:
• Clarity: Ensure teams understand system architecture and decisions.
• Efficiency: Avoid wasteful, outdated documents.
• Collaboration: Use lightweight, living formats (e.g., wikis).
Example: A team maintains a single Confluence page with API endpoints
updated per sprint.

2)Name two tools commonly used for collaborative documentation.

1. Confluence: Integrates with Jira for requirement tracking.
2. Notion: Flexible workspace for wikis, databases, and sprint notes.

3)Why is maintaining up-to-date documentation important in

Agile environments?
• Knowledge Sharing: Onboards new team members quickly.
• Audit Compliance: Meets regulatory needs (e.g., SOC 2).
• Decision Transparency: Records architectural rationale (e.g., why MongoDB
was chosen).
Group 8
1) Explain the MoSCoW framework in prioritizing feedback for implementation

2) List the importance of User Feedback

• Improves Product Fit: Aligns features with user needs.
• Identifies Pain Points: Reveals usability issues (e.g., confusing navigation).
• Drives Innovation: Inspires new features (e.g., voice search requests).
Example: Spotify’s "Discover Weekly" was born from user feedback on music
discovery.

3) What are support requests?

User-reported issues or queries post-release, categorized as:
• Bugs: Functional errors (e.g., "Checkout button crashes").
• How-To Questions: Usage guidance (e.g., "How to export data?").
• Feature Requests: Enhancements (e.g., "Add bulk delete").
Example: A SaaS company uses Zendesk to track and prioritize support tickets.