Modeling requirements involves developing functional requirements from customer views into something translatable to software. Techniques like use cases, state diagrams, UI mockups, storyboards and prototypes are used to understand current systems, business processes, and how users will interact with new systems. The software requirements document specifies what is required of the system and should focus on what the system should do rather than how. Requirements modeling is iterative and requirements change in agile methods.
This document discusses requirements modeling in software engineering. It covers creating various models during requirements analysis, including scenario-based models, data models, class-oriented models, flow-oriented models, and behavioral models. These models form the requirements model, which is the first technical representation of a system. The document provides examples of writing use cases and constructing a preliminary use case diagram for a home security system called SafeHome. It emphasizes that requirements modeling lays the foundation for software specification and design.
This document discusses different process models used in software development. It describes the key phases and characteristics of several common process models including waterfall, prototyping, V-model, incremental, iterative, spiral and agile development models. The waterfall model involves sequential phases from requirements to maintenance without iteration. Prototyping allows for user feedback earlier. The V-model adds verification and validation phases. Incremental and iterative models divide the work into smaller chunks to allow for iteration and user feedback throughout development.
The document discusses use case diagrams in UML modeling. It defines key components of use case diagrams including use cases, actors, the system boundary, and relationships like include, extend, and generalization. It provides examples of how to construct a use case diagram based on system functions and user goals. Specific use case diagram examples shown include an online ordering system and a vending machine.
The document discusses key concepts in software design, including:
- Design involves modeling the system architecture, interfaces, and components before implementation. This allows assessment and improvement of quality.
- Important design concepts span abstraction, architecture, patterns, separation of concerns, modularity, information hiding, and functional independence. Architecture defines overall structure and interactions. Patterns help solve common problems.
- Separation of concerns and related concepts like modularity and information hiding help decompose problems into independently designed and optimized pieces to improve manageability. Functional independence means each module has a single, well-defined purpose with minimal interaction.
The document discusses requirements analysis for software engineering projects. It describes requirements analysis as bridging system requirements and software design by providing models of system information, functions, and behavior. The objectives of analysis are identified as identifying customer needs, evaluating feasibility, allocating functions, and establishing schedules and constraints. Common analysis techniques discussed include interviews, use cases, prototyping, and specification documentation.
This document discusses design patterns, beginning with how they were introduced in architecture in the 1950s and became popularized by the "Gang of Four" researchers. It defines what patterns are and provides examples of different types of patterns (creational, structural, behavioral) along with common patterns in each category. The benefits of patterns are that they enable reuse, improve communication, and ease the transition to object-oriented development. Potential drawbacks are that patterns do not directly lead to code reuse and can be overused. Effective use requires applying patterns strategically rather than recasting all code as patterns.
UML (Unified Modeling Language) is a standard modeling language used to visualize, specify, construct, and document software systems. It uses graphical notation to depict systems from initial design through detailed design. Common UML diagram types include use case diagrams, class diagrams, sequence diagrams, activity diagrams, and state machine diagrams. UML provides a standard way to communicate designs across development teams and is supported by many modeling tools.
This document discusses various topics related to software design including design principles, concepts, modeling, and architecture. It provides examples of class/data design, architectural design, interface design, and component design. Some key points discussed include:
- Software design creates representations and models that provide details on architecture, data structures, interfaces, and components needed to implement the system.
- Design concepts like abstraction, modularity, encapsulation, and information hiding are important to reduce complexity and improve design.
- Different types of design models include data/class design, architectural design, interface design, and component-level design.
- Good software architecture and design lead to systems that are more understandable, maintainable, and of higher quality.
This document discusses requirements modeling in software engineering. It covers creating various models during requirements analysis, including scenario-based models, data models, class-oriented models, flow-oriented models, and behavioral models. These models form the requirements model, which is the first technical representation of a system. The document provides examples of writing use cases and constructing a preliminary use case diagram for a home security system called SafeHome. It emphasizes that requirements modeling lays the foundation for software specification and design.
This document discusses different process models used in software development. It describes the key phases and characteristics of several common process models including waterfall, prototyping, V-model, incremental, iterative, spiral and agile development models. The waterfall model involves sequential phases from requirements to maintenance without iteration. Prototyping allows for user feedback earlier. The V-model adds verification and validation phases. Incremental and iterative models divide the work into smaller chunks to allow for iteration and user feedback throughout development.
The document discusses use case diagrams in UML modeling. It defines key components of use case diagrams including use cases, actors, the system boundary, and relationships like include, extend, and generalization. It provides examples of how to construct a use case diagram based on system functions and user goals. Specific use case diagram examples shown include an online ordering system and a vending machine.
The document discusses key concepts in software design, including:
- Design involves modeling the system architecture, interfaces, and components before implementation. This allows assessment and improvement of quality.
- Important design concepts span abstraction, architecture, patterns, separation of concerns, modularity, information hiding, and functional independence. Architecture defines overall structure and interactions. Patterns help solve common problems.
- Separation of concerns and related concepts like modularity and information hiding help decompose problems into independently designed and optimized pieces to improve manageability. Functional independence means each module has a single, well-defined purpose with minimal interaction.
The document discusses requirements analysis for software engineering projects. It describes requirements analysis as bridging system requirements and software design by providing models of system information, functions, and behavior. The objectives of analysis are identified as identifying customer needs, evaluating feasibility, allocating functions, and establishing schedules and constraints. Common analysis techniques discussed include interviews, use cases, prototyping, and specification documentation.
This document discusses design patterns, beginning with how they were introduced in architecture in the 1950s and became popularized by the "Gang of Four" researchers. It defines what patterns are and provides examples of different types of patterns (creational, structural, behavioral) along with common patterns in each category. The benefits of patterns are that they enable reuse, improve communication, and ease the transition to object-oriented development. Potential drawbacks are that patterns do not directly lead to code reuse and can be overused. Effective use requires applying patterns strategically rather than recasting all code as patterns.
UML (Unified Modeling Language) is a standard modeling language used to visualize, specify, construct, and document software systems. It uses graphical notation to depict systems from initial design through detailed design. Common UML diagram types include use case diagrams, class diagrams, sequence diagrams, activity diagrams, and state machine diagrams. UML provides a standard way to communicate designs across development teams and is supported by many modeling tools.
This document discusses various topics related to software design including design principles, concepts, modeling, and architecture. It provides examples of class/data design, architectural design, interface design, and component design. Some key points discussed include:
- Software design creates representations and models that provide details on architecture, data structures, interfaces, and components needed to implement the system.
- Design concepts like abstraction, modularity, encapsulation, and information hiding are important to reduce complexity and improve design.
- Different types of design models include data/class design, architectural design, interface design, and component-level design.
- Good software architecture and design lead to systems that are more understandable, maintainable, and of higher quality.
UML (Unified Modeling Language) is a diagramming language used for object-oriented programming. It can be used to describe the organization, execution, use, and deployment of a program. Design patterns describe common solutions to programming problems and always use UML diagrams. This document focuses on class diagrams, which show classes, interfaces, and their relationships. It provides examples of how to depict classes with variables and methods, and relationships between classes like inheritance.
The document discusses software requirements and specifications. It explains that requirements engineering is the process of establishing customer requirements for a system. Requirements can range from high-level abstract statements to detailed functional specifications. Both types of statements may be called requirements. The document also discusses different types of requirements like user requirements, system requirements, functional requirements, and non-functional requirements. It provides examples and explanations of each. The structure and intended users of a requirements document are also covered.
This document provides information about a course on design patterns taught by Dr. Asma Cherif. It includes the course code, instructor details, learning objectives, textbooks, and topics that will be covered such as architectural design, what patterns are, and different types of patterns. Design patterns provide solutions to common software design problems and promote reuse of successful designs. The course aims to help students understand design patterns, identify patterns in code and designs, and implement patterns to design and develop quality software applications.
This chapter discusses system modeling and different types of models used, including:
- Context models which illustrate the operational context of a system.
- Interaction models which model interactions between a system and its environment.
- Structural models which display the organization of a system's components.
- Behavioral models which model a system's dynamic behavior in response to events or data.
- Model-driven engineering is discussed as an approach where models rather than code are the primary outputs.
This document discusses various distributed system architectures including centralized, decentralized, and hybrid architectures. It covers software architectures like layered architectures, object-based architectures, and event-based architectures. It also discusses system architectures including client-server, peer-to-peer, structured P2P (like Chord and CAN), unstructured P2P, and hybrid architectures combining centralized and decentralized elements like edge server systems and collaborative distributed systems. Middleware is described as sitting between applications and distributed platforms to provide distribution transparency. Adaptability techniques like interceptors, separation of concerns, reflection, and feedback control loops are also summarized.
The document discusses use case diagrams in object oriented design and analysis. It defines use cases as descriptions of system functionality from a user perspective. Use case diagrams depict system behavior, users, and relationships between actors, use cases, and other use cases. The key components of use case diagrams are described as actors, use cases, the system boundary, and relationships. Common relationships include association, extend, generalization, uses, and include. An example use case diagram for a cellular telephone is provided to illustrate these concepts.
The document discusses software processes and activities. It describes common process models like waterfall, incremental development, and configuration management. The key activities involved in most processes are specification, development, validation, and evolution. Specification defines system requirements while development includes design, implementation, and debugging. Validation ensures the system meets requirements through testing. Processes also evolve to adapt to changing needs.
UML (Unified Modeling Language) is a standard language for specifying, visualizing, and documenting software systems. It uses various diagrams to model different views of a system, such as structural diagrams (e.g. class diagrams), behavioral diagrams (e.g. sequence diagrams), and deployment diagrams. The key building blocks of UML include things (classes, interfaces, use cases), relationships (associations, generalizations), and diagrams. UML aims to provide a clear blueprint of software systems for both technical and non-technical audiences.
PRESCRIPTIVE PROCESS MODEL(SOFTWARE ENGINEERING)IrtazaAfzal3
A prescriptive process model is a model that describes "how to do" according to a certain software process system. ... Prescriptive models are used as guidelines or frameworks to organize and structure how software development activities should be performed, and in what order.
This document discusses the nature of software. It defines software as a set of instructions that can be stored electronically. Software engineering encompasses processes and methods to build high quality computer software. Software has a dual role as both a product and a vehicle to deliver products. Characteristics of software include being engineered rather than manufactured, and not wearing out over time like hardware. Software application domains include system software, application software, engineering/scientific software, embedded software, product-line software, web applications, and artificial intelligence software. The document also discusses challenges like open-world computing and legacy software.
UML (Unified Modeling Language) is a standard modeling language used to specify, visualize, and document software systems. It uses graphical notations to model structural and behavioral aspects of a system. Common UML diagram types include use case diagrams, class diagrams, sequence diagrams, and state diagrams. Use case diagrams model user interactions, class diagrams show system entities and relationships, sequence diagrams visualize object interactions over time, and state diagrams depict object states and transitions. UML aims to simplify the complex process of software design through standardized modeling.
This document provides an introduction and overview of key topics in software engineering. It discusses what software engineering is, the importance and costs of software development, different types of software projects and applications, and issues like complexity, security and scale that affect software. It also introduces software engineering processes, methods, and ethics. Common questions about the field are addressed. The document is the first chapter of a book on software engineering.
The Unified Process (UP) is a software development process that provides guidance on team activities and work integration. It originated from issues with traditional processes being too diverse and outdated. Key aspects of UP include being use-case driven, architecture-centric, and iterative/incremental. UP follows a lifecycle of inception, elaboration, construction, and transition phases within iterative development cycles. While UP addressed issues with prior methods, its weaknesses include not covering the full software process and tools-focus not suiting complex systems.
The document discusses key concepts and principles of software design. It begins by defining design as a blueprint for solving problems specified in requirements. Good design implements all requirements, provides a readable guide, and gives a complete picture of the software. The design process has two levels - top-level design of modules and interfaces and detailed design of module internals. The document then covers fundamental design concepts like abstraction, refinement, modularity, architecture, partitioning, data structures, procedures, information hiding, and functional independence. It provides examples and guidelines for applying these concepts to create a high-quality design.
This document discusses function-oriented software design. It explains that function-oriented design represents a system as a set of functions that transform inputs to outputs. The chapter objectives are to explain function-oriented design, introduce design notations, illustrate the design process with an example, and compare sequential, concurrent and object-oriented design strategies. Topics covered include data-flow design, structural decomposition, detailed design, and a comparison of design strategies.
Architecture design in software engineeringPreeti Mishra
The document discusses software architectural design. It defines architecture as the structure of a system's components, their relationships, and properties. An architectural design model is transferable across different systems. The architecture enables analysis of design requirements and consideration of alternatives early in development. It represents the system in an intellectually graspable way. Common architectural styles structure systems and their components in different ways, such as data-centered, data flow, and call-and-return styles.
The software process involves specification, design and implementation, validation, and evolution activities. It can be modeled using plan-driven approaches like the waterfall model or agile approaches. The waterfall model involves separate sequential phases while incremental development interleaves activities. Reuse-oriented processes focus on assembling systems from existing components. Real processes combine elements of different models. Specification defines system requirements through requirements engineering. Design translates requirements into a software structure and implementation creates an executable program. Validation verifies the system meets requirements through testing. Evolution maintains and changes the system in response to changing needs.
JAD sessions bring together customers and developers to quickly agree on project scope, objectives, and specifications. They are structured workshops facilitated by a trained moderator. Key roles include a facilitator to plan the session and ensure deliverables are produced, decision-makers from the customer who can resolve issues and make commitments, application customers who understand business processes, developer listeners who provide technical input, and a scribe to accurately document the session outcomes. When done effectively, JAD sessions can simplify communication, identify issues, clarify requirements, and gain customer commitment to help ensure the delivered system meets their needs.
This document provides information and instructions for a 3D modeling assignment for Year 12 students at Hillcrest Christian College. It outlines the task of creating an original 3D model in Blender that demonstrates modeling skills learned. Students must submit draft and final models, as well as a design brief and evaluation. They will be assessed on planning, design, skill level, time management, and response to feedback. The "Tick & Flick" checklist outlines various Blender modeling techniques students should utilize in their work. The assignment aims to prepare students for upcoming game development studies in the next semester.
UML (Unified Modeling Language) is a diagramming language used for object-oriented programming. It can be used to describe the organization, execution, use, and deployment of a program. Design patterns describe common solutions to programming problems and always use UML diagrams. This document focuses on class diagrams, which show classes, interfaces, and their relationships. It provides examples of how to depict classes with variables and methods, and relationships between classes like inheritance.
The document discusses software requirements and specifications. It explains that requirements engineering is the process of establishing customer requirements for a system. Requirements can range from high-level abstract statements to detailed functional specifications. Both types of statements may be called requirements. The document also discusses different types of requirements like user requirements, system requirements, functional requirements, and non-functional requirements. It provides examples and explanations of each. The structure and intended users of a requirements document are also covered.
This document provides information about a course on design patterns taught by Dr. Asma Cherif. It includes the course code, instructor details, learning objectives, textbooks, and topics that will be covered such as architectural design, what patterns are, and different types of patterns. Design patterns provide solutions to common software design problems and promote reuse of successful designs. The course aims to help students understand design patterns, identify patterns in code and designs, and implement patterns to design and develop quality software applications.
This chapter discusses system modeling and different types of models used, including:
- Context models which illustrate the operational context of a system.
- Interaction models which model interactions between a system and its environment.
- Structural models which display the organization of a system's components.
- Behavioral models which model a system's dynamic behavior in response to events or data.
- Model-driven engineering is discussed as an approach where models rather than code are the primary outputs.
This document discusses various distributed system architectures including centralized, decentralized, and hybrid architectures. It covers software architectures like layered architectures, object-based architectures, and event-based architectures. It also discusses system architectures including client-server, peer-to-peer, structured P2P (like Chord and CAN), unstructured P2P, and hybrid architectures combining centralized and decentralized elements like edge server systems and collaborative distributed systems. Middleware is described as sitting between applications and distributed platforms to provide distribution transparency. Adaptability techniques like interceptors, separation of concerns, reflection, and feedback control loops are also summarized.
The document discusses use case diagrams in object oriented design and analysis. It defines use cases as descriptions of system functionality from a user perspective. Use case diagrams depict system behavior, users, and relationships between actors, use cases, and other use cases. The key components of use case diagrams are described as actors, use cases, the system boundary, and relationships. Common relationships include association, extend, generalization, uses, and include. An example use case diagram for a cellular telephone is provided to illustrate these concepts.
The document discusses software processes and activities. It describes common process models like waterfall, incremental development, and configuration management. The key activities involved in most processes are specification, development, validation, and evolution. Specification defines system requirements while development includes design, implementation, and debugging. Validation ensures the system meets requirements through testing. Processes also evolve to adapt to changing needs.
UML (Unified Modeling Language) is a standard language for specifying, visualizing, and documenting software systems. It uses various diagrams to model different views of a system, such as structural diagrams (e.g. class diagrams), behavioral diagrams (e.g. sequence diagrams), and deployment diagrams. The key building blocks of UML include things (classes, interfaces, use cases), relationships (associations, generalizations), and diagrams. UML aims to provide a clear blueprint of software systems for both technical and non-technical audiences.
PRESCRIPTIVE PROCESS MODEL(SOFTWARE ENGINEERING)IrtazaAfzal3
A prescriptive process model is a model that describes "how to do" according to a certain software process system. ... Prescriptive models are used as guidelines or frameworks to organize and structure how software development activities should be performed, and in what order.
This document discusses the nature of software. It defines software as a set of instructions that can be stored electronically. Software engineering encompasses processes and methods to build high quality computer software. Software has a dual role as both a product and a vehicle to deliver products. Characteristics of software include being engineered rather than manufactured, and not wearing out over time like hardware. Software application domains include system software, application software, engineering/scientific software, embedded software, product-line software, web applications, and artificial intelligence software. The document also discusses challenges like open-world computing and legacy software.
UML (Unified Modeling Language) is a standard modeling language used to specify, visualize, and document software systems. It uses graphical notations to model structural and behavioral aspects of a system. Common UML diagram types include use case diagrams, class diagrams, sequence diagrams, and state diagrams. Use case diagrams model user interactions, class diagrams show system entities and relationships, sequence diagrams visualize object interactions over time, and state diagrams depict object states and transitions. UML aims to simplify the complex process of software design through standardized modeling.
This document provides an introduction and overview of key topics in software engineering. It discusses what software engineering is, the importance and costs of software development, different types of software projects and applications, and issues like complexity, security and scale that affect software. It also introduces software engineering processes, methods, and ethics. Common questions about the field are addressed. The document is the first chapter of a book on software engineering.
The Unified Process (UP) is a software development process that provides guidance on team activities and work integration. It originated from issues with traditional processes being too diverse and outdated. Key aspects of UP include being use-case driven, architecture-centric, and iterative/incremental. UP follows a lifecycle of inception, elaboration, construction, and transition phases within iterative development cycles. While UP addressed issues with prior methods, its weaknesses include not covering the full software process and tools-focus not suiting complex systems.
The document discusses key concepts and principles of software design. It begins by defining design as a blueprint for solving problems specified in requirements. Good design implements all requirements, provides a readable guide, and gives a complete picture of the software. The design process has two levels - top-level design of modules and interfaces and detailed design of module internals. The document then covers fundamental design concepts like abstraction, refinement, modularity, architecture, partitioning, data structures, procedures, information hiding, and functional independence. It provides examples and guidelines for applying these concepts to create a high-quality design.
This document discusses function-oriented software design. It explains that function-oriented design represents a system as a set of functions that transform inputs to outputs. The chapter objectives are to explain function-oriented design, introduce design notations, illustrate the design process with an example, and compare sequential, concurrent and object-oriented design strategies. Topics covered include data-flow design, structural decomposition, detailed design, and a comparison of design strategies.
Architecture design in software engineeringPreeti Mishra
The document discusses software architectural design. It defines architecture as the structure of a system's components, their relationships, and properties. An architectural design model is transferable across different systems. The architecture enables analysis of design requirements and consideration of alternatives early in development. It represents the system in an intellectually graspable way. Common architectural styles structure systems and their components in different ways, such as data-centered, data flow, and call-and-return styles.
The software process involves specification, design and implementation, validation, and evolution activities. It can be modeled using plan-driven approaches like the waterfall model or agile approaches. The waterfall model involves separate sequential phases while incremental development interleaves activities. Reuse-oriented processes focus on assembling systems from existing components. Real processes combine elements of different models. Specification defines system requirements through requirements engineering. Design translates requirements into a software structure and implementation creates an executable program. Validation verifies the system meets requirements through testing. Evolution maintains and changes the system in response to changing needs.
JAD sessions bring together customers and developers to quickly agree on project scope, objectives, and specifications. They are structured workshops facilitated by a trained moderator. Key roles include a facilitator to plan the session and ensure deliverables are produced, decision-makers from the customer who can resolve issues and make commitments, application customers who understand business processes, developer listeners who provide technical input, and a scribe to accurately document the session outcomes. When done effectively, JAD sessions can simplify communication, identify issues, clarify requirements, and gain customer commitment to help ensure the delivered system meets their needs.
This document provides information and instructions for a 3D modeling assignment for Year 12 students at Hillcrest Christian College. It outlines the task of creating an original 3D model in Blender that demonstrates modeling skills learned. Students must submit draft and final models, as well as a design brief and evaluation. They will be assessed on planning, design, skill level, time management, and response to feedback. The "Tick & Flick" checklist outlines various Blender modeling techniques students should utilize in their work. The assignment aims to prepare students for upcoming game development studies in the next semester.
1) Requirements modeling involves fact-finding activities to describe the current system and identify requirements for the new system. This includes outputs, inputs, processes, performance, security, and modeling techniques.
2) Joint Application Development (JAD) is a popular fact-finding technique that involves users in the development process. Rapid Application Development (RAD) is another technique that speeds up development through prototyping and user involvement.
3) Requirements modeling requires strong analytical and interpersonal skills to build an accurate model through techniques like interviews, documentation review, and questionnaires.
The document discusses various aspects of requirements engineering including processes, techniques, challenges, and importance. It describes requirements elicitation, analysis, specification, validation, and management. Key points covered include feasibility studies, types of requirements, characteristics of good requirements, requirements traceability and evolution. Diagrams like use cases, activity diagrams and data flow diagrams are presented as examples of requirements specification outputs.
Software Engineering- Crisis and Process ModelsNishu Rastogi
The document discusses various software engineering process models including the waterfall model, iterative waterfall model, prototyping model, evolutionary model, rapid application development model, and spiral model. It provides details on the key activities and stages in each model's software development life cycle. The document also compares the different models and discusses when each may be best applied based on factors like the problem's understandability, decomposability into modules, and tolerance for incremental delivery.
Objectives:
1. To understand the different processes in the realm of ‘Requirements Engineering’.
2. To see the challenges in requirements development and the importance of getting requirements right in an IT project.
3. To understand the different techniques used in different phases and processes of requirements development and management.
This ESL lesson is for beginner level English language learners. It provides information about learning English online at the website www.elcivics.com. The lesson aims to teach basic English skills to newcomers getting started with the language.
System modeling involves creating abstract models of a system from different perspectives, such as context, interactions, structure, and behavior. These models help analysts understand system functionality and communicate with customers. Context models show a system's external environment and relationships. Interaction models, such as use case and sequence diagrams, depict how users and systems interact. Structural models, like class diagrams, represent a system's internal organization. Behavioral models, including activity and state diagrams, illustrate a system's dynamic response to events or data. Model-driven engineering aims to generate implementation from system models.
The document provides an introduction to software engineering. It defines software and discusses types of software. It then covers important software quality attributes like reliability, efficiency, usability, and maintainability. The document introduces the software development life cycle, including requirements, design, coding, testing, deployment, and maintenance. It discusses software development methodologies like waterfall model, V-model, and agile scrum.
software development, process model, requirement engineering, srs, structured...Ashok Mohanty
This document provides an overview of software engineering. It begins by discussing the emergence of software engineering as a discipline due to the "software crisis" of the 1970s. It then covers various software engineering processes and lifecycle models, including sequential models like waterfall and iterative models like prototyping and spiral. Requirements engineering methods like elicitation, analysis and specification are also summarized. Finally, it discusses the function-oriented and object-oriented approaches to software development.
A Complete Model Of The Supermarket Business - PresentationFrank Steeneken
This presentation provides a complete picture of the underlying skeletal structure that holds every supermarket business together while achieving it goals. The supermarket model introduces a comprehensive framework for managing the complexity of a supermarket structure, and a reusable blueprint for visualizing how a supermarket company actually does business.
The model’s clearly-defined core-processes and their functions provide a powerful baseline for improving business performance. By viewing a supermarket business as a single functional system, the nature of its underlying core processes become clear. Then by managing and improving them as parts of a single system, substantial improvements can be made on critical success factors, such as lead-time requirements and the precise availability of stock when needed, throughout the supply chain.
Requirements engineering process in software engineeringPreeti Mishra
Requirement Engineering (RE) involves understanding what customers want through tasks like elicitation, negotiation, and specification. RE helps establish requirements that provide a solid foundation for design and construction. The key RE tasks are inception to understand the problem, elicitation by drawing out requirements, elaboration by creating analysis models, negotiation to agree on a realistic solution, specification to formally describe requirements, validation to check for errors or issues, and management of changing requirements. RE helps software engineers better understand problems to solve through participation with customers, managers, and end users.
The document outlines 5 major business strategies for starting a new supermarket: establishing distribution systems, selecting an optimal location, targeting a specific customer demographic, pursuing business alliances, and implementing strong management principles. It explains that properly addressing these areas is crucial for the supermarket's success by attracting customers, building trust, and achieving profitability. Adopting these strategies could help the group's project by providing a framework for their own supermarket business plan.
discuss about System system analysis, system design, system analyst's role, Development of System through analysis, SDLC, Case Tools of SAD, Implementation, etc.
The importance of software since there is were the motivation for software engineering lies and then and introduction to software engineering mentioning the concept and stages of development and working in teams
Requirements modeling involves creating models during requirements analysis to understand current systems or business processes being automated and how users will interact with a new system. It helps with elicitation, validation, and communication of requirements. Common tools for requirements modeling include use cases, state diagrams, UI mockups, storyboards, and prototypes.
Define requirements modeling as representing the customers' needs and the problem domain using models to facilitate understanding between stakeholders.
Explain four roles of requirements modeling as:
1) Guiding elicitation by helping determine questions to ask and uncover hidden requirements
2) Providing progress measures by ensuring model completeness indicates elicitation is complete
3) Hel
The document provides instructions for several common UNIX commands:
1. The "is -l" command lists files in long format with details like size, owner, and modification date.
2. The "cp" and "rm" commands copy and remove files, with "rm -i" requesting confirmation before deleting.
3. The "chmod" command changes permissions on files for users, groups, and others regarding read, write, and execute access.
The document discusses requirements elicitation for software development. It describes the typical activities in a software lifecycle including requirements elicitation, analysis, design, implementation, and testing. It discusses techniques for eliciting requirements such as questionnaires, interviews, document analysis, task analysis, and scenarios. Scenario-based design focuses on concrete examples rather than abstract ideas. Non-functional requirements like usability, performance, and security are also important to define. Eliciting requirements is challenging due to understanding large complex systems and communication between stakeholders.
Unit testing validates individual units or components of software to ensure they perform as designed. Cucumber is a testing framework that uses plain English scenarios in a Given-When-Then format to test software. It supports various programming languages and serves as both documentation and automated tests. Cucumber scenarios are written in feature files, while step definitions contain the actual code to implement the scenarios in code. This allows ensuring scenarios pass by writing code to implement the steps.
Performance Requirements: the Backbone of the Performance Engineering ProcessAlexander Podelko
Performance requirements should to be tracked from system's inception through its whole lifecycle including design, development, testing, operations, and maintenance. They are the backbone of the performance engineering process. However different groups of people are involved in each stage and they use their own vision, terminology, metrics, and tools that makes the subject confusing when you go into details. The presentation discusses existing issues and approaches in their relationship with the performance engineering process.
The document outlines requirements for a Personal Investment Management System (PIMS). PIMS will allow users to track investments in stocks and bank accounts by maintaining portfolios, securities, and transactions. It will compute the net worth and return on investment of a user's portfolio. Key features include creating and managing portfolios and securities, adding transactions, viewing investment details, downloading current stock prices, and getting alerts. The system will be a standalone desktop application that runs on Windows and UNIX and requires internet access to download data.
The document outlines the eight main steps in developing a new computer system: 1) fact finding, 2) feasibility study, 3) analysis phase, 4) system design, 5) testing, 6) implementation, 7) documentation, and 8) evaluation. It provides details on each step, including activities such as identifying requirements, designing outputs and inputs, testing the system, training users, and regularly reviewing the system once complete. The overall process involves thoroughly planning, designing, and testing a new system before implementing it to meet business needs.
This document discusses key aspects of use case modeling including actors, associations, specifications, and common mistakes. It describes actors as entities that trigger use cases and notes they must receive value. Use case associations like include and extend are discussed along with exception and alternative paths. The use case specification template is outlined containing elements like name, description, basic course of events, and references. Finally, common mistakes in use case modeling are listed such as writing functional requirements instead of usage scenarios.
The document discusses the Unified Modeling Language (UML) and use case modeling. UML was developed to provide modeling languages for software design including use case diagrams, class diagrams, and other diagrams. It describes the typical phases of system development like requirements analysis, design, implementation, and testing. It then focuses on use case modeling, explaining what a use case is, how to identify actors and use cases, and how to describe use cases. Examples of use case diagrams are provided for different systems like an ATM machine and counseling.
The document discusses key aspects of software specification including:
1. The importance of requirements engineering in developing an operational model and specification that meets a customer's needs.
2. Components of an operational specification including an overview, model, and set of operations. The model defines an abstract machine for the user to interact with.
3. Constraints that may be placed on the operational model like reliability, security, availability, maintainability, and survivability. These describe non-functional requirements for the system.
Developing a clear operational specification through requirements elicitation and analysis is essential for building the correct software system.
This document discusses the process of requirements elicitation for object-oriented software engineering. It describes identifying actors, scenarios, use cases, relationships between use cases and actors, non-functional requirements, and initial analysis objects. The goal of requirements elicitation is to develop a requirements document that is correct, complete, consistent, unambiguous, realistic, verifiable, and traceable. This is achieved through activities like questions to identify actors and scenarios, elements to include in scenario and use case descriptions, and refining the use case model through iterations with users.
1) The document discusses writing requirements using a use-case model approach. It emphasizes identifying system actors and their goals, as well as use cases that represent meaningful interactions between actors and the system.
2) Key aspects of developing a use-case model are identifying relevant actors, their roles and responsibilities, then analyzing tasks and goals to derive use cases. Actors can represent both human and non-human entities.
3) Use cases should be written from the perspective of actors to ensure requirements capture intended system functionality and meet user needs. The use-case model provides documentation for various stakeholders throughout the software development lifecycle.
Software Requirements Specification-SRS for GIS.pdfJOHNADEMILUYI3
This document provides a software requirements specification (SRS) for the Goya Investment System (GIS). The SRS outlines the purpose, scope, definitions, and overall description of the GIS. It describes functional requirements through use cases for features such as portfolio management, security management, transaction management, computations, alerts, and downloading share prices. The document is intended to guide developers and serve as a validation document for clients.
8 Usability Lessons from the UPA Conference by Mark AlvesMark Alves
This document provides a summary of lessons learned from attending the 2004 UPA Conference in Minneapolis. It outlines 8 key lessons for improving usability at Freddie Mac based on presentations and discussions at the conference: 1) If user tests show a 50-50 split on a design choice, let users decide; 2) Usability labs don't need to be sterile; 3) Join the UTEST community to get input from other practitioners; 4) Speed up design and testing but recognize limitations; 5) Prepare for differences between intranets and enterprise portals; 6) Use Morae software to review user tests; 7) Get useful card sorting results from a small number of users; 8) Create successful online events that feel live through
Agenda
Requirements
What are requirements?
Classifying the requirements
Characteristics of requirements
Requirements elicitation
Documenting the requirements
Requirements analysis and negotiation
Requirements validation
Development)
- Define test strategy and approach
- Estimate test effort and schedule
- Identify risks and contingencies
- Define test environment
- Select tools and techniques
- Estimate test completion criteria
- Produce test plan document
Test planning involves:
- Defining the overall test strategy and approach
- Estimating the test effort and schedule
- Identifying risks and contingencies
- Defining the test environment requirements
- Selecting tools and techniques
- Estimating test completion criteria
- Producing the test plan document
The key outputs of test planning are:
- Test strategy and approach
- Test effort and schedule estimates
- Risks and contingencies plan
- Test environment
This document provides an overview of requirements engineering for software projects. It discusses eliciting requirements through user scenarios and collaboration. It then gives an example user scenario for a home security system called SafeHome. The document outlines principles for software specifications and representation formats. Finally, it discusses reviewing specifications to ensure completeness, consistency and accuracy.
The document describes refactoring a Python web application that manages user accounts and budgets. It outlines several steps to refactor the code to follow best practices like single responsibility principle, anemic domain model, controllers as adapters, tell don't ask, and domain events. The refactor is done through a series of code changes and tests to incrementally improve the structure. The goal is to separate concerns, make the domain models more meaningful, use use cases and commands, and communicate actions through domain events.
The document provides an overview of fundamentals of software development including definitions of software, characteristics of software, software engineering, layered approach to software engineering, need for software engineering, and common software development life cycle models. It describes system software and application software. It outlines characteristics like understandability, cost, maintainability, modularity, reliability, portability, documentation, reusability, and interoperability. It also defines software engineering, layered approach, and need for software engineering. Finally, it explains popular life cycle models like waterfall, iterative waterfall, prototyping, spiral, and RAD models.
The document provides an overview of common Git commands for initializing and cloning repositories, tracking changes, viewing history, branching and merging, and working with remote repositories. It introduces commands for initializing and cloning repositories (git init, git clone), making and viewing changes (git add, git commit, git status, git diff), viewing history (git log), branching and merging (git branch, git checkout, git merge), and interacting with remote repositories (git remote, git fetch, git pull, git push).
This document provides a cheat sheet of common Git commands organized into categories like setup, initialization, branching, sharing/updating, tracking changes, and rewriting history. It summarizes the purpose and basic usage of commands like git init, git add, git commit, git branch, git fetch, git merge, git push, and git log. The cheat sheet is intended to serve as a quick reference guide for the most important and frequently used Git commands.
Static white-box testing involves carefully reviewing software design, architecture, or code without executing it to find bugs. It provides access to internal code to find bugs early that may be difficult to discover with black-box testing alone. Formal reviews are the primary method, ranging from peer reviews between two programmers to inspections with multiple trained reviewers following strict roles and procedures to thoroughly check for problems from different perspectives. Checklists cover common errors like uninitialized variables, out-of-bounds array indexing, data type mismatches, computation overflows, and incorrect control flow or parameter handling.
The document discusses various aspects of web testing including:
1) Features that make websites complex such as customizable layouts, dynamic content, and compatibility with different browsers and devices.
2) The basics of web testing including treating each page as a "black box" and creating a state table to map connections between pages.
3) Elements to test on web pages including text, hyperlinks, graphics, forms, and other features; and ensuring proper loading, sizing, and functionality across different browsers, versions, and devices.
Types of software documentation include packaging, marketing materials, warranties, end user license agreements, labels, installation instructions, user manuals, online help, tutorials, samples, examples, and error messages. Software documentation is an important part of the overall software product that users interact with. Good documentation improves usability, reliability, and lowers support costs by helping users understand and correctly use the software. As a software tester, documentation should be treated with the same level of attention and testing as the code itself to ensure a high quality overall product.
A secure product protects customers' information and system resources from unauthorized access. As a software tester, it is important to understand why hackers may try to break into software in order to think of where security vulnerabilities could exist. Threat modeling involves assembling a team to identify assets, architecture, potential threats, and their risks to find areas of the software's features that may be vulnerable to security issues. Testing for security bugs should approach testing as "test-to-fail" by attacking the software like a hacker would to assume every feature could have a vulnerability.
The document discusses fundamentals of testing, including black-box and white-box testing techniques. It also provides details on reviewing product specifications, such as pretending to be the customer, researching standards and guidelines, and reviewing similar software. Key aspects to check in specifications include completeness, accuracy, and precision. Testing techniques covered include equivalence partitioning and boundary value analysis for black-box testing and unit testing, code analysis and coverage for white-box.
The document discusses test planning and outlines several topics that should be addressed in a test plan, including high-level expectations, people and resources, definitions, test phases and strategies, resource requirements, tester assignments, schedules, test cases, bug reporting, metrics, and risks. The overall goal of test planning is to communicate the testing team's intentions, expectations, and understanding of the testing to be performed.
The document discusses the importance of carefully planning test cases for software testing. It outlines four key reasons for planning test cases: organization, repeatability, tracking, and proving testing was conducted. It also discusses the IEEE 829 standard for test design, test cases, and test procedures. The standard provides guidance on what information should be included in test cases, such as identifiers, test items, input/output specifications, and dependencies. It also outlines what should be covered in test procedures, including purpose, procedure steps, logging results, and contingencies.
Software testing involves several key activities: (1) defining test plans and cases to evaluate software attributes and capabilities, (2) executing tests to uncover errors manually or automatically, and (3) analyzing and reporting test results. The objectives of testing include finding errors, validating requirements are met, and ensuring quality. Testers, engineers, and quality assurance groups all perform various testing roles and activities throughout the software development lifecycle. Effective testing requires independence, planning, and understanding that complete testing is impossible due to risks and limitations of time and resources.
Compatibility testing ensures that software interacts correctly with other programs. This includes sharing data through various methods such as saving to different file formats, copying and pasting between programs, and transferring data using standards like DDE and OLE. Thorough testing is needed to check compatibility with other platforms, applications, and versions based on high-level standards for user experience as well as low-level technical standards for file formats and communication protocols.
Dynamic black-box testing involves testing software without knowledge of its internal code by entering inputs, observing outputs, and checking results. The document discusses techniques for effective dynamic black-box testing including reducing test cases using equivalence partitioning, identifying boundary conditions, using various data values and states to find bugs, and applying repetition and high loads. It also covers using exploratory testing when requirements are not available and the approaches of test-to-pass and test-to-fail.
Automated testing and test tools can speed up the testing process, improve efficiency and accuracy, reduce resource needs, and enable simulation. While tools are not a replacement for testers, they can help testers perform their jobs better. It is important to note that using tools is not always the right choice, and manual testing is still needed in some cases.
The document discusses why testing software is important by providing examples of bugs and failures that could have been avoided with better testing, such as missing names on checks and data conversion errors that caused satellite failures. It then outlines the types of questions testing aims to answer about software functionality, user experience, performance, and readiness. Testing helps identify defects early to save time and money, avoid downtime, and build better applications that satisfy users.
Git is a version control system that allows for branching and merging of code. GitHub is a hosting service for Git repositories that enables collaboration through features like forking and pull requests. Heroku is a cloud platform that supports various programming languages and allows applications to be deployed through Git pushes. The cheat sheet outlines common Git commands for configuration, branching, merging, staging changes, viewing history and comparing differences. It also provides examples of workflows for contributing to GitHub projects and deploying applications to Heroku.
This document discusses various types of static white box testing techniques including formal reviews, peer reviews, walkthroughs, and inspections. Formal reviews involve following rules and writing a report. Peer reviews involve two programmers reviewing each other's code. Walkthroughs involve a programmer presenting code to reviewers. Inspections are the most formal with trained roles and perspectives. Checklists are provided to review for errors in data declarations, computations, comparisons, control flow, subroutine parameters, and input/output. White box testing finds bugs early by reviewing design and code without executing it.
Software testing is focused on finding defects. Important past defects found include missing names on 50,000 social security checks due to a software error, a flaw in nuclear tracking software, data conversion errors that caused the loss of the NASA Mars Climate Orbiter, and a floating point error that caused the loss of the $500 million Ariane 5 rocket. Testing answers questions about functionality, requirements, user experience, compatibility, performance, and scalability to identify defects early and improve customer satisfaction.
Software testing involves evaluating a system or program to determine if it meets its requirements and to identify any errors. There are many definitions of software testing but generally it involves executing a program and attempting to find bugs or errors. The objectives of testing are to uncover as many errors as possible, demonstrate the software matches requirements, and validate quality with minimal cost and effort. Testing activities include planning tests, designing and specifying test cases, setting up the environment, executing tests, analyzing results, and managing the testing process. Verification ensures the software is built correctly while validation ensures the right product is being built. Complete testing is impossible so testing is risk-based and must be planned with independence from the developers.
This document discusses software quality assurance. It defines software as computer programs, procedures, and documentation related to operating a computer system. Software quality is defined as meeting requirements and user needs/expectations. Quality factors include correctness, reliability, efficiency, integrity, usability, maintainability, flexibility, testability, portability, reusability, and interoperability. Software quality assurance is a planned set of actions to provide confidence that software development/maintenance conforms to requirements and schedules/budgets. The objectives of SQA are to assure acceptable confidence in conforming to functional/managerial requirements during development and maintenance. Three principles of QA are to know what is being done, know what should be done, and know how to
This document discusses software measurement and identifies key issues that should be measured in projects. It explains that measurement is important to make reasonable decisions but can be time-consuming. The document identifies common issues to measure like schedule, cost, size, quality, ability, and performance. These issues provide important information about staying on budget and time, meeting requirements, and product quality. Measuring the right things is crucial for project success.
The Science of Learning: implications for modern teachingDerek Wenmoth
Keynote presentation to the Educational Leaders hui Kōkiritia Marautanga held in Auckland on 26 June 2024. Provides a high level overview of the history and development of the science of learning, and implications for the design of learning in our modern schools and classrooms.
8+8+8 Rule Of Time Management For Better ProductivityRuchiRathor2
This is a great way to be more productive but a few things to
Keep in mind:
- The 8+8+8 rule offers a general guideline. You may need to adjust the schedule depending on your individual needs and commitments.
- Some days may require more work or less sleep, demanding flexibility in your approach.
- The key is to be mindful of your time allocation and strive for a healthy balance across the three categories.
Brand Guideline of Bashundhara A4 Paper - 2024khabri85
It outlines the basic identity elements such as symbol, logotype, colors, and typefaces. It provides examples of applying the identity to materials like letterhead, business cards, reports, folders, and websites.
How to Download & Install Module From the Odoo App Store in Odoo 17Celine George
Custom modules offer the flexibility to extend Odoo's capabilities, address unique requirements, and optimize workflows to align seamlessly with your organization's processes. By leveraging custom modules, businesses can unlock greater efficiency, productivity, and innovation, empowering them to stay competitive in today's dynamic market landscape. In this tutorial, we'll guide you step by step on how to easily download and install modules from the Odoo App Store.
Artificial Intelligence (AI) has revolutionized the creation of images and videos, enabling the generation of highly realistic and imaginative visual content. Utilizing advanced techniques like Generative Adversarial Networks (GANs) and neural style transfer, AI can transform simple sketches into detailed artwork or blend various styles into unique visual masterpieces. GANs, in particular, function by pitting two neural networks against each other, resulting in the production of remarkably lifelike images. AI's ability to analyze and learn from vast datasets allows it to create visuals that not only mimic human creativity but also push the boundaries of artistic expression, making it a powerful tool in digital media and entertainment industries.
Post init hook in the odoo 17 ERP ModuleCeline George
In Odoo, hooks are functions that are presented as a string in the __init__ file of a module. They are the functions that can execute before and after the existing code.
2. – 2 –
Modeling Requirements:Modeling Requirements:
from customer views to something translatablefrom customer views to something translatable
to softwareto software
echniques for developing functional requirements
What the software is supposed to do!
3. – 3 –
Requirements modeling
We build models in requirements analysis or/andWe build models in requirements analysis or/and
specifications to understandspecifications to understand
current systems or business processes which we are
trying to automate
how users will use a new system
4. – 4 –
The software requirements
document
The software requirements document is the officialThe software requirements document is the official
statement of what is required of the systemstatement of what is required of the system
developers.developers.
Should include both a definition of userShould include both a definition of user
requirements and a specification of the systemrequirements and a specification of the system
requirements.requirements.
It is NOT a design document. As far as possible, itIt is NOT a design document. As far as possible, it
should set WHAT the system should do rathershould set WHAT the system should do rather
than HOW it should do it.than HOW it should do it.
4
5. – 5 –
Agile methods and
requirements
Many agile methods argue that producing aMany agile methods argue that producing a
requirements document is a waste of time asrequirements document is a waste of time as
requirements change so quickly.requirements change so quickly.
The document is therefore always out of date.The document is therefore always out of date.
Methods such as XP use incremental requirementsMethods such as XP use incremental requirements
engineering and express requirements asengineering and express requirements as ‘user‘user
stories’stories’
This is practical for business systems and gamesThis is practical for business systems and games
but problematic for systems that require a lot ofbut problematic for systems that require a lot of
pre-delivery analysis (e.g. critical systems) orpre-delivery analysis (e.g. critical systems) or
systems developed by several teams, e.g.,systems developed by several teams, e.g.,
large government systems.large government systems.
5
6. – 6 –
Requirements document
variability
Information in requirements document depends onInformation in requirements document depends on
the type of system and the approach tothe type of system and the approach to
development used.development used.
Systems developed incrementally will, typically,Systems developed incrementally will, typically,
have less detail in the requirements document.have less detail in the requirements document.
Requirements documents standards have beenRequirements documents standards have been
designed e.g. IEEE standard. These are mostlydesigned e.g. IEEE standard. These are mostly
applicable to the requirements for large systemsapplicable to the requirements for large systems
engineering projects.engineering projects.
6
7. – 7 –
Requirements and Design
In principle, requirements should state what theIn principle, requirements should state what the
system should do and the design shouldsystem should do and the design should
describe how it does this.describe how it does this.
In practice, requirements and design areIn practice, requirements and design are
inseparableinseparable
A system architecture may be designed to
structure the requirements;
The system may inter-operate with other
systems that generate design requirements;
The use of a specific architecture to satisfy
non-functional requirements may be a domain
requirement.
This may be the consequence of a regulatory
requirement.
8. – 8 –
Tools for modeling
requirements
Use CasesUse Cases – in late 70s, my advisor wrote a tech– in late 70s, my advisor wrote a tech
paper on how to do thispaper on how to do this
State DiagramsState Diagrams
UI MockupsUI Mockups – standard process in DoD and auto– standard process in DoD and auto
industry – (Not in my kitchen)industry – (Not in my kitchen)
StoryboardsStoryboards
PrototypesPrototypes
9. – 9 –
Functional Reqs:
What should it do?
Functional Reqs:
What should it do?
Developer
connect mysql
database to
asp .net web
…
Client
sell my
beautifu
l jewelry
Customer of client
find a
cool
ring on
sale
10. – 10 –
Client
sell my
beautifu
l jewelry
Customer of client
find a
cool
ring on
sale
User-centric: What, not how
Difficult to express
Functional Reqs:
What should it do?
11. – 11 –
Modeling functional Reqs
Identify user classesIdentify user classes
Example:
jewelry store owner
buyer of jewelry
12. – 12 –
Modeling functional reqs
Identify user classesIdentify user classes
For each user class identify goalsFor each user class identify goals
Example
Buyer:
search for item
place an order
return an item
13. – 13 –
Modeling functional reqs
Identify user classesIdentify user classes
For each user class identify goalsFor each user class identify goals
For each user class/goalFor each user class/goal
Describe how the user will use the system
14. – 14 –
Example
Name: Order jewelry from a catalogName: Order jewelry from a catalog
Actors: Customer Alice, Sales rep Bob,Actors: Customer Alice, Sales rep Bob,
Stockroom, Shipping dept.Stockroom, Shipping dept.
Initiator: AliceInitiator: Alice
Scenario:Scenario:
1.1. Alice calls companyAlice calls company
2.2. Bob answers phoneBob answers phone
3.3. Alice says she wants to place an order fromAlice says she wants to place an order from
the catalogue.the catalogue.
4.4. Bob asks how the order will be paid.Bob asks how the order will be paid.
5.5. …… USE CASE
15. – 15 –
Forms of Use Cases
Casual –Casual – “user stories”“user stories”
Fully dressed use cases – preconditions, post-Fully dressed use cases – preconditions, post-
conditions, actors, stakeholders, etc.conditions, actors, stakeholders, etc.
…
these are cultural issues
but in agile methods, less is more
16. – 16 –
Key aspects of Use Case
NameName: what we call this use case: what we call this use case
ActorsActors: entities that interact with system (typically: entities that interact with system (typically
people but also can be other systems)people but also can be other systems)
InitiatorInitiator: actor who initiates the use case: actor who initiates the use case
ScenarioScenario: sequence of steps users take and how: sequence of steps users take and how
system respondssystem responds
17. – 17 –
Example: Main scenario
Name: Order jewelry from a catalogName: Order jewelry from a catalog
Actors: Customer Alice, Sales rep Bob, Stockroom, ShippingActors: Customer Alice, Sales rep Bob, Stockroom, Shipping
dept.dept.
Initiator: AliceInitiator: Alice
Scenario:Scenario:
1.1. Alice calls companyAlice calls company
2.2. Bob answers phoneBob answers phone
3.3. Alice says she wants to order item X.Alice says she wants to order item X.
4.4. Bob checks stockroom for availability.Bob checks stockroom for availability.
5.5. Stockroom says it is available.Stockroom says it is available.
6.6. ……
18. – 18 –
Main scenario with branchesMain scenario with branches
Name: Order jewelry from a catalogName: Order jewelry from a catalog
Actors: Customer Alice, Sales rep Bob, Stockroom, ShippingActors: Customer Alice, Sales rep Bob, Stockroom, Shipping
dept.dept.
Initiator: AliceInitiator: Alice
Scenario:Scenario:
1.1. Alice calls companyAlice calls company
2.2. Bob answers phoneBob answers phone
3.3. Alice says she want to order item D23 from page 5 theAlice says she want to order item D23 from page 5 the
catalogue.catalogue.
4.4. Bob checks stockroom for availability.Bob checks stockroom for availability.
5.5. Stockroom says it is available.Stockroom says it is available.
5a. Stockroom says it is not available. See order out of5a. Stockroom says it is not available. See order out of
stock item use case.stock item use case.
6. ….6. ….
Alternative path can be completed or refer to another
use case.
19. – 19 –
Use case development
Brainstorm to identify Use CasesBrainstorm to identify Use Cases
Validate/prioritize/ensure consistencyValidate/prioritize/ensure consistency
Elaborate high priority/complex use casesElaborate high priority/complex use cases →→
identify new Use Casesidentify new Use Cases
Repeat until _________________Repeat until _________________
Waterfall: until done – done keeps moving
Agile: until good enough for now
20. – 20 –
Sequence Diagram -
Alternative
Sequence Diagram -
Alternative
Alice: Customer
Bob: Sales rep Stockroom
call on phone
answers phone
wants to order
…
21. – 21 –
Example: Pac Man Use Cases
Actor Goal/Title Priority
User Play game 1
User Initialize game 1
User View high scores 3
User Set level 3
User Pause game 2
User Exit game 2
User Save game 3
User Change Controls 4
User Play saved game 3
22. – 22 –
Elaborated Use Case
Play gamePlay game::
1.1. User choosesUser chooses “Play Game” from main menu.“Play Game” from main menu.
2.2. Start level is displayed with player having 3 livesStart level is displayed with player having 3 lives
3.3. User moves Pac Man left, right, up, down –User moves Pac Man left, right, up, down – (point to(point to
other UC)other UC)
4.4. Pac Man moves to empty space, return to step 3Pac Man moves to empty space, return to step 3
4.a.4.a. Pac Man hits dot but not end of level, 50 pointsPac Man hits dot but not end of level, 50 points
awarded, return to step 3awarded, return to step 3
4.b.4.b. Pac Man hits dot and level ends, 50 points awarded andPac Man hits dot and level ends, 50 points awarded and
new level starts (seenew level starts (see start new level use casestart new level use case))
4.c. Pac Man hits ghost (see4.c. Pac Man hits ghost (see hits ghost use casehits ghost use case))
4.d. Pac Man hits a wall, can4.d. Pac Man hits a wall, can’t move any further in that’t move any further in that
direction, returns to step 3 with new constraintdirection, returns to step 3 with new constraint
etc.etc.
23. – 23 –
Refined Use Case
Play game:Play game:
1.1. User choosesUser chooses “Play Game” from main menu.“Play Game” from main menu.
2.2. Start levelStart level displayeddisplayed with 3 lives and 0 scorewith 3 lives and 0 score
3.3. Play level (see separate use case)Play level (see separate use case)
4.4. Repeat 3 on successive levels until game overRepeat 3 on successive levels until game over
24. – 24 –
Refined Use Case (no UI spec)
Play game:Play game:
1.1. User chooses to play gameUser chooses to play game
2.2. First level starts with 3 lives and 0 scoreFirst level starts with 3 lives and 0 score
2.2. Play level (see separate use case)Play level (see separate use case)
3.3. Repeat 3 on successive levels until game overRepeat 3 on successive levels until game over
How do you refine a Use Case??
Talk to user!!
25. – 25 –
Pac Man Use Cases
Actor Goal Priority
User Play game 1
User Play level 1
User Initialize game 1
User View high scores 3
User Set level 3
User Pause game 2
User Exit game 2
User Save game 3
User Change Controls 4
User Play saved game 3
26. – 26 –
Agile method: goal stackAgile method: goal stack
highest priority, best modeled
use case, e.g, Play UC
lowest priority, least modeled
use case, e.g., store game history
prioritized
use cases
27. – 27 –
Uses of use case
RequirementsRequirements::
Define functional requirements
Expose business rules (constraints on behavior)
PlanningPlanning: Suggest an iterative strategy: Suggest an iterative strategy
DesignDesign: Validate design models, i.e., does design: Validate design models, i.e., does design
provide for Use Caseprovide for Use Case
TestingTesting: Provide scenarios for validation testing: Provide scenarios for validation testing
28. – 28 –
Requirement Quality
Specify what not howSpecify what not how
UnambiguousUnambiguous
TestableTestable
FeasibleFeasible
ConsistentConsistent
PrioritizedPrioritized
Traceable – Agile: back to requestorTraceable – Agile: back to requestor
Interative: back to aInterative: back to a
specification #specification #
Agreed upon by customerAgreed upon by customer
How can Use Cases contribute to quality in
functional requirements?
29. – 29 –
Tools for modeling (functional)
requirements
Tools for modeling (functional)
requirements
Use CasesUse Cases
State DiagramsState Diagrams
UI MockupsUI Mockups
StoryboardsStoryboards
PrototypesPrototypes
good for describing
“flow”
30. – 30 –
State diagramsState diagrams
Moves to
empty spot
Pac Man has n lives,
score k
moves left, right, up,
down
Hits ghost:
Sound effect
n reduced by 1
Lose level
n=0
n>0
Hits dot:
Sound effect
k increased by 50
k<MAX
Win level
Play level: initialize n=3 (#lives), k=0 (level score)
k<0
31. – 31 –
Tools for modeling (functional)
requirements
Tools for modeling (functional)
requirements
Use CasesUse Cases
State DiagramsState Diagrams
UI MockupsUI Mockups
StoryboardsStoryboards
PrototypesPrototypes
good for describing “flow”
Better for state machines
32. – 32 –
UI Mock UP
• UI Mock Up (or even full design) is often
considered part of the requirements process
because it summarizes the ways a user can
interact with the system.
• UI design can also address non functional
requirements, e.g., look and feel
33. – 33 –
Storyboards
Good for communicating “look and feel” inGood for communicating “look and feel” in
addition to “flow”addition to “flow”
(again addressing non-functional requirements)
(Indian Jones vs Casablanca movies)
Missing in my GPS experience
34. – 34 –
Tools for modeling (functional)
requirements
Use CasesUse Cases
State DiagramsState Diagrams
UI MockupsUI Mockups
StoryboardsStoryboards
PrototypesPrototypes
these are special cases of prototypes
35. – 35 –
Prototypes
Sample level with simplified art, minimal features
Use fast prototyping tools to clarify functionality, look and feel, etc.
36. – 36 –
Which model should you use?
All that are appropriate!
Invent new ones as needed!
37. – 37 –
Requirements for games
Game Designer
Management
Marketing
Users
…
Software engineers
38. – 38 –
Top down game specificationTop down game specification
High conceptHigh concept
Competitive analysisCompetitive analysis
Main characterMain character
Game MechanicsGame Mechanics
Underlying modelsUnderlying models
Major featuresMajor features
Look and feelLook and feel
ScoringScoring
UIUI
etc.etc.
Traditional
Game Design Document
“Game Bible”
39. – 39 –
Bottom up game specificationBottom up game specification
Use casesUse cases
State diagramsState diagrams
UI mock upsUI mock ups
StoryboardsStoryboards
PrototypesPrototypes
Make your vision “concrete”
Discover technical requirements:
• Display sprite
• Move sprite
• Detect collision
• etc.
Address feasibility
Suggest iterative design/development
strategy
40. – 40 –
Agile method: goal stack
initial top goals – risks, proof of conceptinitial top goals – risks, proof of concept
move
sprite
display
sprite
level 0
prioritized
use cases,
proofs of concept
proof of concept to
understand feasibility
use case