Podcast
Questions and Answers
Requirements specification involves gathering information about the work environment and desired outcomes.
Requirements specification involves gathering information about the work environment and desired outcomes.
True
Architectural design only focuses on the aesthetic appearance of the system.
Architectural design only focuses on the aesthetic appearance of the system.
False
Detailed design includes multiple refinements while preserving the intended behavior of the system.
Detailed design includes multiple refinements while preserving the intended behavior of the system.
True
Coding and unit testing occurs before architectural design.
Coding and unit testing occurs before architectural design.
Signup and view all the answers
The transformation from natural language to an executable language is crucial for successful development.
The transformation from natural language to an executable language is crucial for successful development.
Signup and view all the answers
Study Notes
HCI in the Software Process
- The goal is to create effective, user-friendly interactive systems, moving beyond identifying design paradigms to thoroughly examining the process.
- Emphasis is placed on integrating user-centered design into software development frameworks.
- Software engineering (a key field in computer science) manages technical and managerial aspects of development using a software life cycle.
- This life cycle encompasses everything from initial idea to retirement, including activities from concept to eventual replacement.
- HCI considerations are integrated into every stage of the life cycle, not as an isolated activity.
- The software life cycle provides a structured approach for applying techniques in software development.
- Activities in the software life cycle involve distinct stages arranged in a waterfall model structure.
- The activities include: requirements, architectural, detailed, coding/unit testing, integration/testing, and maintenance.
- Maintenance is the most significant portion of the software lifecycle.
The Software Life Cycle
- Software engineering provides a structure for applying techniques in developing software systems.
- The life cycle defines and orders activities occurring during software development.
- Key parties involved are the customer (who needs the product) and the designer (who creates it).
- It's crucial to distinguish between customers who commission designs and end-users who utilize the system.
Activities in the Life Cycle
- Requirements Specification: Designers and clients define what the system should do, focusing on outcomes rather than implementation details. This involves gathering information about the environment, functionality, and interactions with other products. Initial documentation uses natural language, though it eventually needs translation to an executable language.
- Architectural Design: This phase focuses on how to achieve the specified goals. The system is decomposed into manageable components, which might use existing software, or be developed anew. Interdependencies and resource-sharing are considered.
- Detailed Design: This refines the architectural component descriptions, preserving intended behavior. Options are evaluated considering non-functional requirements like performance and usability. Important is documented design decisions and rationale.
- Coding and Unit Testing: This step implements the detailed design components in an executable programming language. Testing occurs to meet established criteria, focused on both automating coding and testing processes.
- Integration and Testing: Components are integrated according to the architectural design, using shared resources. Acceptance testing (often by the customer) confirms if the system meets requirements to release the system. Certification by relevant external authorities, and regulations such as ISO 9241, are considered.
- Maintenance: Involves fixing discovered errors in the post-release phase, updating for new requirements, and providing feedback to improve the system.
Verification
- Verification is a process to ensure the software meets requirements and design specifications. It confirms if the system is being built correctly.
- The goal is to find errors early in the process.
- Questions answered by verification relate to: "Are we building the correct system?", and "Does the system meet the design specification requirements?"
Validation
- Validation assesses if the software meets user needs and expected functionality in real-world scenarios.
- This focuses on whether the correct product has been built.
- The goal is to ensure the system is suitable for its purpose and provides value to users.
- Questions answered by validation relate to: "Are we building the right system?", and "Does the system meet the needs and expectations of users?"
Usability Engineering
- Usability engineering defines specific goals and criteria to evaluate how usable a product is to users.
- It emphasizes understanding how usability is measured from user experiences, considering both the user interface and systems' overall structure.
- Usability constraints focus on observable physical interactions, rather than more complex aspects of user interaction.
- A usability specification is part of the requirements specification, to detail usability attributes impacting the system.
- Examples include a table specifying attributes for undo actions with a VCR.
ISO usability standard 9241
- This standard adopts traditional usability categories for evaluating systems.
- These include effectiveness, efficiency, and satisfaction.
- The standard provides metrics used to measure the usability of the system according to these categories.
Problems with Usability Engineering
- Usability metrics can be challenging because they are based on specific actions and contexts, which may not be known at the design stage.
- Ensuring usability specifications are met doesn't guarantee overall usability and appropriate user experience.
- Designers must understand how changes in metrics affect the user experience to ensure adjustments align with real needs.
Iterative Design and Prototyping
- Requirements for interactive systems may not be fully defined at the start; iterative refinement helps.
- Iterative design processes involve cycling through designs and refining them based on feedback collected from users.
- This allows for accurate design features, modifications, and improvements.
- Iterative designs are not limited to usability but encompass the larger issues in software engineering.
- Prototypes that simulate or animate aspects of the system are used; these can take on different forms: throwaway, incremental, and evolutionary.
Techniques for Prototyping
- Storyboards: Visual representations useful for visualizing user interactions, workflows.
- Limited Functionality Simulations: Simpler versions of the software, highlighting core concepts or workflows.
- High-Level Programming Support: More functional prototypes, closer to the final product in terms of functionality.
Design Rationale
- Design rationale explains the choices made during the software development.
- This includes the reasoning behind decisions, evaluated alternatives, and alignment with overall project goals.
- Documentation of design rationale is important for explaining choices to stakeholders, ensuring transparency, and facilitating issue resolution.
- Design rationale documents and reflects on choices throughout the entire life cycle.
Importance of Design Rationale
- Design rationale helps with clarity and understanding of decisions to stakeholders.
- It facilitates justification of decisions, especially during disagreements or when changes are required.
- It enables future references, improving communication and consistency.
Examples of Design Rationale
- User Interface: Rationale might include chosen layout based on user feedback, ease of navigation, and alignment with user goals.
- System Architecture: Architecture rationale addresses choices made, like choosing microservices over monoliths and considerations like maintainability, scalability, and deployment.
Process-Oriented Design Rationale
- The IBIS method involves using Rittel's IBIS framework.
- This structure helps to structure design discussions based on central issues, supported positions, and opposing arguments.
- Visualizations (gIBIS), clarifies the relationship among issues, positions and arguments.
- Variations of IBIS exist with design artefacts or richer vocabularies.
Design Space Analysis
- Approaches for analyzing design space (like QOC Notation), helps evaluate and structure the design process.
- Documentation aids in future reference; however, it requires extra time and may not always be suitable for tight resources.
Psychological Design Rationale
- This perspective focuses on understanding the usability experience.
- Emphasis is put on associating design decisions to user tasks.
- Tools like electronic spreadsheets can be examples of how design tools evolve over time and meet wider user needs.
Identifying Tasks, Creating Scenarios and Reflection
- The process involves identifying key tasks, creating user scenarios, documenting implementation, and reflecting on the system's use.
- The goal is to understand how user tasks evolve and use this to create improvements in later iterations.
Studying That Suits You
Use AI to generate personalized quizzes and flashcards to suit your learning preferences.
Related Documents
Description
This quiz explores the integration of Human-Computer Interaction (HCI) principles into the software development life cycle. It emphasizes the importance of a user-centered design approach throughout all stages, from initial requirements to maintenance. Test your knowledge on how HCI enhances the creation of effective, user-friendly software systems.