Chapter 11writing Excellent Requirements1111 Characteristics Of Exce ✓ Solved

Chapter 11 Writing Excellent Requirements .1 Characteristics of excellent requirements .2 Guidelines for writing requirements .3 Exercises Chapter 12 A Picture Is Worth 1024 Words © Karl E. Wiegers Models provide high-level view, SRS provides details. Models must be consistent with SRS and each other. Conflicts between alternative views reveal errors. Requirements Analysis and Modeling Modeling Techniques 12.1 Structured analysis models 1.a)data flow diagram & ER- Diagram 1.b)state-transition diagram 1.c) Flow Chart (Swimlane Diagram) 1.d) Dialog map 12.2 Object-oriented analysis models 2.a)use case diagram 2.b)class diagram 2.c)collaboration diagram 2.d)sequence diagram 2.e)state chart diagram 2.f)activity diagram 12.3 Decision Table and Decision Tree .a) Data Flow Diagram Level 1 data flow diagram for the Chemical Tracking System 6 See Supplement 7Figure 11-2.

Partial entity-relationship diagram for the Chemical Tracking System 1.b) State-Transition Diagrams Partial state-transition diagram for a home security system 10 State-transition diagram for a chemical request in the CTS .c) Flow Chart – describes the flow of logic 12 The swim lane differs from flowcharts in that processes and decisions are grouped visually by placing them in lanes. Parallel lines divide the chart into lanes, with one lane for each person, group or sub-process. Lanes are labeled to show how the chart is organized. 1d) Dialog Map 13 Represents a user interface design at high level of abstraction. It shows the dialog elements in the system and the navigation links among them without showing the detailed screen design.

Find incorrect or missing transitions early Find incorrect or missing requirements early Find navigation dead-ends Define user back-out and cancellation routes Spot reuse opportunities or redundancies in UI design Can partition the user interface into components Can draw dialog maps hierarchically, to control scope and complexity Benefits of Dialog Map 2.a) Use Case Diagram (as discussed in chapter .b) Class Diagrams Class diagram for part of the Chemical Tracking System .c) Collaboration Diagram (interaction 1) Ex. Library Management .d) Sequence Diagram (interaction 2) Ex. ATM 23 See Supplement .e) State Chart Diagram (similar to “State-Transition-Diagramâ€) ATM example 25 Check Events in S.D. .f) Activity diagram is a flowchart-based diagram showing flow of control from activity to activity.

It shows concurrency, branch, control flow and object flow. 27 Swim-lane, furthermore, is used for partitioning the activity states. 28 Summary State Chart Diagram 3.b) Decision Tables and Decision Trees Techniques for representing what the system to do when complex logic and decision come into play. 29 A Sample Decision Table Decision Tree A Sample Decision Tree 32 Ex. Sample Decision Tree for CTS END 33 Chapter 14: Beyond Functionality: Software Quality Attributes © Karl E.

Wiegers 1 Quality Distinguishes Products ï‚— Functional requirements (features) may only satisfy a customer ï‚— Quality attributes make customers “enjoy†your product (an old-fashioned view of quality) ï‚— Quality attributes are often critical to product usefulness (the architecture-centric view) ï‚— Quality attributes are harder to elicit from customers—they don’t usually think to volunteer them 2 Software Quality Attributes . Quality Attributes For Users ï‚— Availability â—¦ Uptime / (Uptime + Downtime) â—¦ Downtime can be scheduled or unscheduled â—¦ Driven by business and safety needs â—¦ Could be time-dependent ï‚— Efficiency â—¦ Minimal consumption of resources â—¦ Needs to consider spikes, growth 4 ï‚— Flexibility â—¦ Ease of adding new capabilities â—¦ Essential for incremental, iterative development ï‚— Integrity â—¦ Blocking unwanted access â—¦ Enforcing privacy â—¦ Preventing data loss 5 ï‚— Interoperability â—¦ Exchange of data with other systems â—¦ File and message formats ï‚— Reliability â—¦ Operation without failure â—¦ Related to availability â—¦ Trade off impact severity against development cost.

6 ï‚— Robustness â—¦ Continued operation when faced with invalid inputs, unexpected conditions ï‚— Usability â—¦ Can be very subjective â—¦ Effort to provide inputs, use outputs â—¦ Often specified in terms of task times . Quality Attributes For Developers ï‚— Maintainability â—¦ Defect correction â—¦ Feature enhancement â—¦ Related to flexibility â—¦ Understandable, simple design 8 ï‚— Portability â—¦ Preparing for variations in operating environment â—¦ Hardware platform, operating system, database, GUI. ï‚— Reusability â—¦ Using components in other applications â—¦ Modular, independent, well-documented, generic software ï‚— Testability â—¦ Ease of looking for, finding defects â—¦ Affects design guidelines for complexity .

Performance Requirements ï‚— Speed of functions â—¦ Response time â—¦ Throughput â—¦ Capacity â—¦ Timing deadlines ï‚— Can, however, affect system safety 10 Summary of Quality Attributes . Documenting Quality Attributes (quantifiable and verifiable) . Quality Attribute Relationships (Trade-offs) . Implementing Nonfunctional Requirements 15 Integrity, interoperability, robustness, usability, safety Functional requirements Availability, efficiency, flexibility, performance, reliability System architecture Interoperability, usability Design constraint Flexibility, maintainability, portability, reliability, reusability, testability, usability Design guideline Portability Implementation constraint END 16 Chapter 13 Specifying Data Requirement © Karl E.

Wiegers . Entity-Relationship Diagram Partial entity-relationship diagram for the Chemical Tracking System -Relationship -Cardinality 2. Class Diagram (used in UML) - see also chapter Class Diagram for ATM . Data Dictionary (used in data Flow Diagram) Uses BNF (extended) notation This has 3 fundamental constructs. sequence  selection ï› ï¼ ï Repetition { } ( ) optional = is compose of 6 ï‚— Ex. name ï‚— name =title + First-name + (middle-name) + last-name ï‚— title =[Mr | Miss | Mrs…] ï‚— First-name = {legal-char}  most ï‚— Middle-name = {legal-char}1 10 at least ï‚— Last-name = {legal-char}1 12 ï‚— Legal-char = [A-Z ï¼ a-z ï¼-] . Data Analysis CRUD Matrix gives relationship between Use-cases and data objects (see below) 8 ï‚— CRUD can show possibly missing requirement - There is no “D†for an object “requester†- What does it mean? - Possibly a missing requirement ?

9 END 10 Chapter 15: Risk Reduction Through Prototyping © Karl E. Wiegers .1 Why do Prototyping? 2 Dialog Map Karl Wiegers 3 Lower the expectation Gap 15.2 Prototype Types  Horizontal Prototypes ï‚— Behavioral mockup—most common type ï‚— Broad but not deep—functional but slow, fragile, unreliable ï‚— Shows look and feel, flow of tasks 4 Vertical Prototypes ï‚— Proof of concept ï‚— Narrow but deep—limited set of features, but complete implementation of them ï‚— Works like real system, for evaluation of: â—¦ Architecture approach â—¦ Algorithm optimization 5 Throwaway Prototypes ï‚— Decide early about “discard†or “deliver† Throwaways are quick and dirty, poorly engineered and constructed ï‚— Most useful for user interfaces â—¦ Use case â—¦ Dialog map â—¦ Detailed user interface design 6 Evolutionary Prototypes ï‚— Incremental product builds â—¦ Trial versions â—¦ Pilot releases ï‚— Must be well-designed and carefully constructed. ï‚— User feedback will come from operation in actual working environment .3 Combined Approach Throwaway Evolutionary Horizontal - Clarify and refine use - Implement core use cases cases and functional - Implement additional use requirements cases based on priority - Identify missing - Implement and refine Web functionality sites - Explore user interface - Adapt system to rapidly approaches changing needs Vertical - Demonstrate technical - Implement and grow core feasibilities client/server functionality and communication layers - Implement and optimize core algorithms - Test and tune performances .4 Prototyping: Suggestions .5 Evaluation of the prototype ï‚— Ask the user specific questions (not just “what do you think?â€) â—¦ Is this what you expected? â—¦ Is anything missing? â—¦ Are there errors that weren't addressed? â—¦ Is there anything unnecessary present? â—¦ Is navigation logical, complete? â—¦ Is anything too complex? .6 Success Factors ï‚— Plan the effort ï‚— Have a clear purpose, draw boundaries ï‚— Be quick, not robust ï‚— Don’t prototype if you already understand ï‚— Use plausible data ï‚— Don’t use prototype as requirements specification .7 Risks ï‚— Customer will ask for delivery of a throwaway â—¦ Do it on paper â—¦ Use nonproduction tools ï‚— Customer will develop a poor opinion of the product's performance or reliability 12 END 13 Chapter 16: Setting Requirement Priorities © Karl E.

Wiegers .1 Why Prioritize? ï‚— Competition for limited resources ï‚— Balance project scope against: â—¦ Schedule â—¦ Budget â—¦ Staff â—¦ Quality ï‚— Have multiple options early (which way to go) 2 Things that can happen - ï‚— Refusal to set priorities: “it’s all equally important.† Biased priorities: 85% are high (although not the case) ï‚— Late-breaking “rapid de-scopingâ€- in a panicked state ï‚— Too many resources spent on low-priority, eventually-deferred functions 3  Questions to ask ï‚— Is there another way to do this? ï‚— What are the consequences of deleting this requirement? ï‚— What is the business impact of delaying this requirement? ï‚— Why would a user be unhappy if this requirement were missing? ï‚— What is the least-important requirement of all? (can be repeated to build priority list) .2 Prioritization Techniques  In or out: stake holders make binary decision Pair-wise comparison and rank ordering: Assign unique priority number to each requirement and make pairwise comparison  Three level Scale (High, Medium and Low) based on Importance and Urgency  MoSCoW (Moscow) For each Req, decide, if it is - M: Must - the REQ must be satisfied - S: Should - be but not mandatory - C: Could – implement only permitting - Won’t – will not be implemented It gives 4 level scale (but no rational) No 2 dimension as in three scale  not highly recommended 7 ï‚— Priority = value % (cost % * cost weight) + (risk % * risk weight) 8  Prioritization based on Value, Cost and Risk -Estimating Relative Customer Value of Features (weight = Estimating Feature Priority (weight = Prioritization Example: A Word Processor (weight = (Weight) (2.0) (1.0) (1.0) (0.5) Feature RelativeBenefit Relative Penalty Total Value Value % Relative Cost Cost % Relative Risk Risk % Priority Print a material safety data sheet Query status of a vendor order Generate a Chemical Stockroom inventory report See history of a specific chemical container Search vendor catalog for a specific chemical Maintain a list of hazardous chemicals Modify a pending chemical request Generate an individual laboratory inventory report Check training database for hazardous chemical training record Import chemical structures from structure drawing tools Totals ...0 Priority = value % (cost % * cost weight) + (risk % * risk weight)Table .

Value, Cost, and Risk Another Example: Chemical Factory (Exercise) 13 (Weight) (2.0) (1.0) (1.0) (0.5) Feature RelativeBenefit Relative Penalty Total Value Value % Relative Cost Cost % Relative Risk Risk % Priority Print a material safety data sheet .5 1 2.7 1 3.0 1.22 Query status of a vendor order .4 2 5.4 1 3.0 1.21 Generate a Chemical Stockroom inventory report .1 5 13.5 3 9.1 0.89 See history of a specific chemical container .7 3 8.1 2 6.1 0.87 Search vendor catalog for a specific chemical .8 3 8.1 8 24.2 0.83 Maintain a list of hazardous chemicals .7 3 8.1 4 12.1 0.68 Modify a pending chemical request .1 3 8.1 2 6.1 0.64 Generate an individual laboratory inventory report .0 4 10.8 3 9.1 0.59 Check training database for hazardous chemical training record .5 4 10.8 2 6.1 0.47 Import chemical structures from structure drawing tools .6 9 24.3 7 21.2 0.33 Totals ...0 Priority = value % (cost % * cost weight) + (risk % * risk weight)Table . Value, Cost, and Risk Another Example: Chemical Factory Prioritization END 14

Paper for above instructions

Introduction

In software engineering, the process of documenting requirements is fundamental to ensuring that the final product aligns with user expectations and business objectives. Requirements are not just mere statements of what features a system should have; they embody the vision, constraints, and critical functionalities that drive the software's design and implementation. However, to be effective, requirements must be of high quality.

Characteristics of Excellent Requirements

Good requirements must meet several characteristics to be considered excellent. The following are key attributes:
1. Clear and Concise: Requirements should be expressed in simple language that is easily understood by all stakeholders (Wiegers & Beatty, 2013). Jargon and technical language should be minimized unless they are widely accepted by the audience.
2. Testable: Each requirement must be verifiable through testing methods, which may include performance metrics, acceptance criteria, or inspection (Leffingwell, 2011). Without this quality, it is impossible to validate the requirement's implementation.
3. Unambiguous: Requirements should not be open to multiple interpretations. Ambiguity can lead to scope creep, miscommunication, and project failure (Sommerville, 2011). It is advisable to define terms explicitly or include a glossary if necessary.
4. Consistent: Requirements must not contradict each other. Inconsistencies can cause confusion and must be resolved to avoid implementation problems (Wiegers & Beatty, 2013).
5. Prioritized: Requirements should have an associated priority level, determining their importance relative to project goals. Prioritization helps in efficient resource allocation and in making trade-off decisions when needed (Wiegers, 2013).
6. Feasible: Requirements must be achievable within the constraints of the project's time, budget, and technology (Boehm, 1987). Unfeasible requirements significantly impact project viability.
7. Traceable: Good requirements should be traceable back to their origin or justification, whether financial, business, or legal reasons. Traceability is crucial for managing changes and validating compliance (IEEE, 2011).

Guidelines for Writing Requirements

Creating effective requirements is an art as much as it is a science. The following guidelines can facilitate the writing process:
1. Use the Standard Requirement Template: Adopting a consistent format can enhance clarity and comprehension. Example templates include but are not limited to functional requirements templates and user story formats (Cohn, 2004).
2. Engage Stakeholders: Involve users, sponsors, and technical teams to elicit requirements from diverse perspectives (Alfaro et al., 2013). Regular workshops, brainstorming sessions, and interviews can gather insights and expectations effectively.
3. Employ Modeling Tools: Use visual models like use case diagrams, flowcharts, or entity-relationship diagrams to represent complex requirements visually. This aids in understanding and can reveal ambiguities or errors early (Sommerville, 2011).
4. Document All Types of Requirements: Distinguish between functional and non-functional requirements. Non-functional requirements, such as quality attributes, are often equally important but can be harder to articulate (Wiegers, 2013).
5. Utilize Acceptance Criteria: Specify acceptance criteria for each requirement. This creates a clear standard against which the completed work can be measured (Leffingwell, 2011).
6. Keep Iterating: Requirements writing should be an iterative process. As development progresses, revisit and refine requirements based on new information or changing circumstances (Agile Alliance, 2020).
7. Review and Validate: Conduct regular reviews of requirements with stakeholders to ensure they remain aligned with project goals. Validation sessions can catch issues early and improve stakeholder engagement.
8. Educate Team Members: Ensure that all team members understand how to read and interpret requirements. Training sessions or workshops can help disseminate best practices for working with requirements documents (Summerville, 2011).

Exercises

To solidify understanding, it can be beneficial to engage in exercises that encourage the practice of writing and evaluating requirements. Some examples include:
1. Requirement Writing Drill: Task participants with writing specific requirements based on a hypothetical software application.
2. Peer Review Sessions: Pair participants to evaluate each other's requirements for clarity, conciseness, and testability.
3. Model Creation: Use modeling tools to derive structured representations of written requirements, enhancing visualization skills.
4. Prioritization Challenges: Provide a list of requirements and ask participants to prioritize them based on strict criteria to convey the importance of prioritization.
5. Role-Playing: Create a simulated stakeholder environment where participants must elicit requirements, fostering skills in communication and negotiation.

Conclusion

Writing excellent requirements is crucial for successful software development. By adhering to key characteristics of quality requirements and following practical guidelines, software teams can avoid common pitfalls that lead to misunderstandings, project delays, and budget overruns. Consequently, this systematic approach fosters enhanced collaboration among teams and stakeholders while producing software that truly meets user needs.

References

1. Alfaro, A., & Garcia, J. (2013). Software Requirements: A Process to Capture Business Needs. New York: Academic Press.
2. Agile Alliance. (2020). The Agile Manifesto. Available at: https://agilemanifesto.org/principles.html.
3. Boehm, B. W. (1987). Software Engineering Economics. Englewood Cliffs, NJ: Prentice-Hall.
4. Cohn, M. (2004). User Stories Applied: For Agile Software Development. Boston: Addison-Wesley.
5. IEEE. (2011). IEEE Std 830-1998: IEEE Recommended Practice for Software Requirements Specifications. New York: IEEE.
6. Leffingwell, D. (2011). Scaling Software Agility: Best Practices for Curating Teams, Aligning Deliverables, and the World of Work. Boston: Addison-Wesley.
7. Sommerville, I. (2011). Software Engineering (9th ed.). Boston: Addison-Wesley.
8. Wiegers, K.E. (2013). Software Requirements (3rd ed.). Redmond, WA: Microsoft Press.
9. Wiegers, K.E. & Beatty, J. (2013). Software Requirements (3rd ed.). Redmond, WA: Microsoft Press.
10. Agile Alliance. (2020). Requirements Gathering: A Software Development Method - Agile vs. Waterfall. Available at: https://www.agilealliance.org/agile101/what-is-agile/