Mada za sehemu hiiIdentifying and analysing software development requirementsMada 3
- Collecting requirements
- Analysing requirements
- Modelling use cases
Analysing Requirements
After gathering requirements from stakeholders through interviews, questionnaires, observation, and other techniques, the next step is to analyse them. Requirements analysis is the process of refining and structuring the gathered requirements to clearly define what the system must do and how it should behave. This ensures that the collected user needs are well-organized, complete, and properly documented before moving to the design phase.
Without proper analysis, the system may not meet user needs, leading to wasted time and resources. Analysis helps identify gaps, remove contradictions, and prioritize what is most important for the system.
When analysing requirements, we categorize them into two main types: functional requirements and non-functional requirements. A third category called constraints also limits what the system can do.
Functional Requirements
Functional requirements define what the system should do. They describe the specific features, operations, and behaviours the system must provide. These requirements answer the question: "What functions will the system perform?"
How to write functional requirements:
- Use active voice and the keyword "shall"
- Be clear and specific; avoid vague phrases like "user-friendly"
- State testable requirements that can be verified
Examples of functional requirements (Student Information Management System):
- The system shall allow teachers to enter and update student grades.
- The system shall generate examination reports at the end of each term.
- The system shall send SMS notifications to parents about student performance.
- The system shall allow students to view their grades online.
Non-Functional Requirements
Non-functional requirements define how well the system should behave rather than what it should do. They describe the system's qualities, including performance, security, usability, and reliability.
How to write non-functional requirements:
- Use active voice and the keyword "should"
Common types of non-functional requirements:
- Performance: How fast the system responds (e.g., "The system should load the dashboard within 2 seconds")
- Scalability: How the system handles increased users or data volume
- Security: Measures to protect data (e.g., encryption, authentication)
- Usability: How easy it is for users to learn and operate the system
- Reliability: The system's ability to function correctly over time
- Availability: Expected uptime (e.g., 99.9% uptime)
- Maintainability: How easy it is to update or fix the system
- Portability: Ability to run on different platforms
Examples of non-functional requirements (SIMS):
| Requirement | Type |
|---|---|
| The system shall respond to user requests within 2 seconds. | Performance |
| The system shall store all student data securely using encryption. | Security |
| The system shall support at least 500 users accessing it simultaneously. | Scalability |
| The system shall be accessible 99% of the time. | Availability |
Constraints
Constraints are limitations or conditions that restrict the development or operation of the system. These may include:
- Budget limitations
- Technology availability (e.g., "The system must work on basic feature phones")
- Timeframes
- Legal or regulatory requirements
- Network limitations (e.g., "The system must work offline")
When analysing requirements, you must:
- Categorize each requirement as functional, non-functional, or constraint
- Prioritize requirements based on:
- User importance
- System feasibility
- Development complexity
Priority levels:
- Must-have: Essential for the system to work (e.g., login functionality)
- Should-have: Important but not critical (e.g., SMS notifications)
- Nice-to-have: Optional features that add value (e.g., dark mode theme)
After categorizing requirements, we communicate them visually using use case diagrams. A use case diagram shows how users (actors) interact with the system.
Key elements:
- Actor: A user or external system that interacts with the system (shown as a stick figure)
- Use case: A specific action or interaction (drawn as an oval)
- Relationships: Lines connecting actors to use cases
Types of relationships:
- Association: Shows interaction between actor and use case (solid line)
- <
> : Shows one use case always calls another - <
> : Shows optional functionality
Worked Example: Library Services System (LSS)
Let's categorize requirements for a Library Services System:
Gathered requirements:
- Students can borrow books
- The system should respond within 3 seconds
- Librarians can add new books
- The system must encrypt all member passwords
- Students can return books
- The system should work on slow internet connections
- Only librarians can delete book records
Categorized:
| Functional Requirements | Non-Functional Requirements | Constraints |
|---|---|---|
| The system shall allow students to borrow books. | The system shall respond within 3 seconds. | The system must work on slow internet connections. |
| The system shall allow librarians to add new books. | The system shall encrypt all member passwords. | |
| The system shall allow students to return books. | ||
| The system shall allow only librarians to delete book records. |
In Tanzania, when a school or hospital wants to computerize its records, a systems analyst first analyses requirements before developing any software. For example, if Mwalimu Nyerere Secondary School in Dodoma wants a system to manage student attendance and marks, the analyst must determine what the system must do (functional) and how well it should perform (non-functional), ensuring the final system works reliably even with limited internet connectivity in the area.
Jinsi utakavyotathminiwaTathmini ya mchakato · Tathmini ya matokeo · Tathmini ya maarifa
Tathmini ya mchakato
- Accurately categorize requirements into appropriate groups.
- Validate and prioritize requirements according to project constraints and goals.
- Clearly document analysis outcomes.
Tathmini ya matokeo
A detailed requirements analysis report, including categorized, prioritized, and validated requirements.
Tathmini ya maarifa
Detailed knowledge of:
Method used: The student should explain how to
- categorize requirements (such as functional, and non-functional).
Principles: The student should explain the principles of:
- aligning with project objectives and traceability of requirements.
Theories: The student should explain:
- requirements engineering process
- requirements validation (e.g., feasibility, consistency, completeness)
Circumstantial knowledge:
Detailed knowledge about:
- scenarios requiring tradeoffs between requirements and practical solutions for resolving conflicts.
Swali
What is the main purpose of requirements analysis in system development?
Ingia ili kuwasilisha jibu lako na lihesabiwe katika umahiri wako.
Ingia ili kufanya mazoeziMwalimu
Umekwama? Niulize chochote kuhusu mada hii.
Ingia ili kumuuliza Mwalimu wa AI wa Sonza kuhusu swali hili.
Ingia ili kuulizaMajadiliano
Hakuna maswali bado