CSE320 Unit 3 Notes

Unit III: Object Modelling

User Interface Design

Introduction to User Interface (UI) Design

User Interface (UI) Design is the process of creating interfaces in software or computerized devices, focusing on appearance and style to facilitate easy and efficient interaction between the user and the system.

• Goal: Enhance user satisfaction by improving the usability, accessibility, and pleasure provided in the interaction between the user and the product.

Objectives:

• Enhance User Experience: Make interactions intuitive and engaging.
• Improve Efficiency: Enable users to perform tasks with minimal effort and time.
• Facilitate Usability: Ensure the interface is easy to learn and use, reducing errors.

Principles of UI Design

Adhering to core principles ensures that the UI meets user needs and provides a positive experience.

Clarity

• Definition: The interface should present information and controls in a clear and understandable manner.
• Strategies:
  • Use simple and familiar language.
  • Avoid clutter and excessive information.
  • Ensure visual elements are distinguishable.

Consistency

• Definition: Maintain uniformity across the interface to reduce user learning curve.
• Strategies:
  • Use consistent layouts, colors, fonts, and controls.
  • Apply standard conventions and patterns.
  • Ensure navigation and workflows are predictable.

Feedback

• Definition: Provide users with timely responses to their actions.
• Strategies:
  • Use visual cues (e.g., progress bars, notifications).
  • Confirm actions (e.g., "Your file has been saved").
  • Highlight errors and guide users to correct them.

Efficiency

• Definition: Allow users to achieve their objectives with minimal effort.
• Strategies:
  • Streamline workflows and minimize steps.
  • Provide shortcuts for experienced users.
  • Optimize performance to reduce wait times.

Accessibility

• Definition: Design interfaces that are usable by people with a wide range of abilities and disabilities.
• Strategies:
  • Support assistive technologies (e.g., screen readers).
  • Use high-contrast color schemes.
  • Ensure navigability via keyboard and voice controls.

UI Design Process

A structured approach to UI design helps create effective interfaces.

Requirement Gathering

• Objective: Understand the needs, goals, and expectations of users.
• Activities:
  • Conduct interviews and surveys.
  • Analyze user tasks and context of use.
  • Identify constraints and limitations.

User Research

• Objective: Gain insights into user behaviors and motivations.
• Methods:
  • Personas: Fictional characters representing user types.
  • Scenarios: Narratives describing how users might interact with the system.
  • User Journey Mapping: Visualizing the steps users take to achieve tasks.

Information Architecture

• Definition: Organize and structure content logically.
• Activities:
  • Develop site maps outlining the structure.
  • Categorize information into groups.
  • Design navigation schemes.

Wireframing and Prototyping

• Wireframing:
  • Purpose: Create low-fidelity sketches of the interface layout.
  • Focus: Placement of elements, navigation, and basic interactions.
• Prototyping:
  • Purpose: Develop interactive models to simulate user experience.
  • Types:
    • Low-Fidelity Prototypes: Basic simulations without detailed design.
    • High-Fidelity Prototypes: Closely resemble the final product.

Visual Design

• Activities:
  • Choose color palettes that align with branding and improve readability.
  • Select typography that enhances legibility.
  • Design icons and graphics that aid recognition.

Usability Testing

• Objective: Validate the UI design with real users.
• Methods:
  • Conduct user tests to observe interactions.
  • Collect feedback on ease of use and satisfaction.
  • Identify pain points and areas for improvement.

Iterative Process

• Explanation: Repeat steps based on feedback until the design meets user needs effectively.

UI Design Tools

Various tools assist designers in creating and testing UI designs.

Sketch

• Features: Vector design toolkit, prototyping capabilities.
• Usage: Designing interfaces for web, mobile, and desktop applications.

Adobe XD

• Features: UI design and prototyping, supports collaboration.
• Usage: Creating interactive prototypes with animations.

Figma

• Features: Cloud-based design tool, real-time collaboration.
• Usage: Designing, prototyping, and sharing designs with team members.

Balsamiq

• Features: Rapid wireframing tool with a sketch-like interface.
• Usage: Creating low-fidelity wireframes quickly.

Best Practices

Implementing best practices improves the quality and effectiveness of the UI.

Simplify Interfaces

• Approach: Remove unnecessary elements that do not contribute to user goals.
• Benefit: Reduces cognitive load and enhances focus.

Prioritize Content

• Approach: Place the most important information and controls prominently.
• Benefit: Ensures critical features are easily accessible.

Ensure Responsive Design

• Approach: Design interfaces that adapt to different screen sizes and devices.
• Techniques:
  • Use flexible grids and layouts.
  • Implement media queries in CSS.

Use Standard UI Elements

• Approach: Apply common controls like buttons, menus, and checkboxes.
• Benefit: Leverages users' familiarity, reducing learning time.

Provide Help and Documentation

• Approach: Include tooltips, help sections, and error explanations.
• Benefit: Assists users in overcoming challenges independently.

Unified Process

Introduction to the Unified Process (UP)

Unified Process (UP) is an adaptable, iterative, and incremental software development framework that provides a disciplined approach to assigning tasks and responsibilities within a development organization.

• Origin: Developed by Rational Software Corporation, resulting in the Rational Unified Process (RUP).

Core Concepts

Iterative Development

• Definition: Dividing the project into small segments, called iterations, where each iteration results in an increment of the product.
• Benefits:
  • Allows for early detection and correction of problems.
  • Accommodates changes in requirements.
  • Provides tangible progress throughout development.

Use Case Driven

• Definition: Focuses on capturing and fulfilling functional requirements through use cases, which describe system interactions from the user's perspective.
• Benefits:
  • Aligns development activities with user needs.
  • Facilitates understanding among stakeholders.

Architecture-Centric

• Definition: Emphasizes the importance of a robust and extensible architecture to ensure system quality and maintainability.
• Approach:
  • Define a baseline architecture early in the project.
  • Continually refine architecture throughout iterations.

Phases of the Unified Process

The UP is organized into four sequential phases, each consisting of one or more iterations.

Inception Phase

• Objective: Establish the project's scope and feasibility.
• Key Activities:
  • Identify key stakeholders and their needs.
  • Define initial use cases and critical requirements.
  • Estimate costs, schedule, and resources.
  • Assess risks and develop mitigation strategies.
• Deliverables:
  • Vision Document
  • Initial Project Plan
  • Risk Assessment
  • Use Case Model (initial version)

Elaboration Phase

• Objective: Analyze the problem domain and establish the system's foundational architecture.
• Key Activities:
  • Refine and prioritize use cases.
  • Elaborate the system's architecture through prototypes and models.
  • Continue risk assessment and mitigation.
  • Create detailed project plan for the construction phase.
• Deliverables:
  • Architectural Prototype
  • Updated Risk Assessment
  • Refined Use Case Model
  • Software Architecture Document

Construction Phase

• Objective: Develop the software components and features.
• Key Activities:
  • Implement and test the software according to the architecture.
  • Integrate components and subsystems.
  • Perform code reviews and quality assurance.
• Deliverables:
  • Software Product (beta version)
  • Test Cases and Test Results
  • User Documentation (draft)

Transition Phase

• Objective: Deploy the system to the end-users and ensure it meets their needs.
• Key Activities:
  • Conduct user training and support.
  • Perform beta testing and gather feedback.
  • Make final adjustments and enhancements.
  • Prepare for system release and maintenance.
• Deliverables:
  • Final Software Product
  • User Documentation
  • Training Materials
  • Release Notes

Disciplines (Workflows)

The UP defines various disciplines that encompass the activities performed during each phase.

Business Modeling

• Purpose: Understand the business context and processes.
• Activities: Develop business use cases and process models.

Requirements

• Purpose: Capture and analyze the system requirements.
• Activities: Define use cases, functional and non-functional requirements.

Analysis and Design

• Purpose: Transform requirements into a design suitable for implementation.
• Activities: Create design models, define system architecture, and design components.

Implementation

• Purpose: Code and build the software components.
• Activities: Write source code, compile, and integrate components.

Testing

• Purpose: Verify the software meets requirements and is defect-free.
• Activities: Develop and execute test cases, report defects, and retest fixes.

Deployment

• Purpose: Deliver the product to end-users and ensure it operates in the target environment.
• Activities: Install software, migrate data, and conduct acceptance testing.

Configuration and Change Management

• Purpose: Control changes to software artifacts and maintain integrity.
• Activities: Version control, change requests, and tracking.

Project Management

• Purpose: Plan, monitor, and control the project.
• Activities: Scheduling, resource allocation, risk management.

Environment

• Purpose: Provide the necessary tools and processes to support the project.
• Activities: Set up development environment, define processes, and select tools.

Benefits

• Effective Risk Management:
  • Iterative cycles allow for early identification and mitigation of risks.
• Accommodates Change:
  • Incremental development enables adaptation to changing requirements.
• Quality Architecture:
  • Emphasis on architecture ensures scalability, performance, and maintainability.
• Stakeholder Involvement:
  • Regular feedback from stakeholders improves alignment with user needs.
• Improved Project Visibility:
  • Frequent deliverables enhance tracking of progress and schedule adherence.

Object Modelling using UML

Introduction to UML (Unified Modeling Language)

Unified Modeling Language (UML) is a standardized general-purpose modeling language in software engineering that provides a set of graphical notation techniques to create visual models of object-oriented software systems.

Purpose

• Visualization: Represent complex systems in an understandable manner.
• Specification: Define system structure and behavior precisely.
• Documentation: Record design decisions and architecture.
• Construction: Serve as a blueprint for system implementation.

Fundamental UML Diagrams

UML includes various diagrams divided into two categories: Structural and Behavioral diagrams.

Structural Diagrams

Class Diagram

• Description: Depicts the static structure of the system, showing classes, attributes, operations (methods), and relationships.
• Components:
  • Classes: Represented by rectangles divided into three sections (name, attributes, operations).
  • Relationships: Associations, dependencies, generalizations.

Object Diagram

• Description: Shows a snapshot of instances (objects) and their relationships at a particular moment.
• Usage: Visualize examples of data structures.

Component Diagram

• Description: Illustrates the organization and dependencies among software components.
• Components:
  • Components: Executable pieces of software or modules.
  • Interfaces: Points of interaction with other components.

Deployment Diagram

• Description: Represents the physical deployment of artifacts on nodes.
• Components:
  • Nodes: Hardware or execution environments.
  • Artifacts: Executable or data files.

Behavioral Diagrams

Use Case Diagram

• Description: Depicts system functionalities (use cases) and interactions with external entities (actors).
• Components:
  • Actors: Users or other systems.
  • Use Cases: Oval shapes representing system functions.

Sequence Diagram

• Description: Shows object interactions in a time sequence.
• Components:
  • Lifelines: Represent objects or participants over time.
  • Messages: Communications between lifelines.

Activity Diagram

• Description: Captures dynamic aspects of the system, representing workflows of activities.
• Components:
  • Actions/Activities: Rounded rectangles.
  • Control Flows: Arrows indicating the sequence.

State Machine Diagram

• Description: Describes states of an object and transitions due to events.
• Components:
  • States: Rounded rectangles.
  • Transitions: Arrows indicating state changes.

Steps in Object Modelling Using UML

Identify the Objects

• Activity: Determine the key entities within the system based on requirements.
• Sources:
  • Use Cases: Identify objects involved in interactions.
  • Domain Knowledge: Consider standard entities in the problem domain.

Define Classes and Class Hierarchy

• Activity: Assign attributes and operations to classes.
• Considerations:
  • Attributes: Characteristics or properties of classes.
  • Operations: Functions or methods the class can perform.
• Hierarchy:
  • Establish inheritance relationships (generalization/specialization).

Establish Relationships

• Types of Relationships:
  • Association: A structural connection between classes (e.g., "a customer places an order").
  • Aggregation: A whole-part relationship where the part can exist independently (e.g., "a team consists of players").
  • Composition: A strong whole-part relationship where the part cannot exist independently (e.g., "a house has rooms").
  • Inheritance: A subclass derives from a superclass.

Create UML Diagrams

• Activity: Graphically represent the system's structure and behavior using appropriate UML diagrams.
• Purpose: Visualize and communicate the design effectively.

Refine and Iterate

• Approach: Continuously update the models based on feedback, new requirements, or design insights.
• Benefit: Ensures models remain accurate and relevant.

Benefits of Using UML

• Standardization: Provides a common language for developers and stakeholders.
• Clarity: Helps in understanding complex systems through visual representation.
• Communication: Facilitates collaboration among team members.
• Design Validation: Enables early detection of design flaws.
• Documentation: Serves as comprehensive documentation for future maintenance.

Use Case Model Development

Definition of Use Case

A Use Case describes a sequence of actions, including variants, that a system performs to yield an observable result of value to an actor.

• Actor: An external entity (person, organization, or system) that interacts with the system.

Components of a Use Case

Actors

• Definition: Entities that interact with the system to achieve a goal.
• Types:
  • Primary Actor: Initiates interaction to achieve a goal.
  • Secondary Actor: Assists the system in fulfilling the use case.

Use Cases

• Definition: Specific functionalities or services provided by the system to meet actor goals.
• Characteristics:
  • Should deliver value to the actor.
  • Defined using verb-noun phrases (e.g., "Process Order").

Relationships

• Association: Connection between actors and use cases, indicating interaction.
• Include: A use case includes the behavior of another use case as part of its flow.
• Extend: A use case extends the behavior of another use case under certain conditions.
• Generalization: Inheritance between use cases or actors, indicating a specialized relationship.

Steps to Develop Use Case Models

Identify Actors

• Activity: Determine all entities that interact with the system.
• Considerations:
  • Who uses the system?
  • Who provides or receives information?

Identify Use Cases

• Activity: List functionalities that the actors require from the system.
• Methods:
  • Brainstorming sessions.
  • Analyzing user tasks and goals.

Create Use Case Diagrams

• Activity: Draw diagrams representing actors and their associated use cases.
• Components:
  • Use case symbols (ovals).
  • Actor symbols (stick figures).
  • Associations (lines connecting actors to use cases).

Write Use Case Descriptions

• Activity: Develop detailed narratives for each use case.
• Elements:
  • Use Case Name
  • Brief Description
  • Preconditions: Conditions that must be true before the use case starts.
  • Main Flow: Step-by-step sequence of actions.
  • Alternate Flows: Variations in the main flow.
  • Postconditions: The state of the system after the use case completes.

Types of Use Case Relationships

Include

• Definition: A use case includes the behavior of another use case.
• Usage: Reuse common functionality across multiple use cases.
• Notation: Dashed arrow with «include» keyword.

Extend

• Definition: A use case extends the behavior of another use case under specific conditions.
• Usage: Represent optional or conditional behavior.
• Notation: Dashed arrow with «extend» keyword.

Generalization

• Definition: Indicates inheritance between use cases or actors.
• Usage: Model commonalities and differences.
• Notation: Solid line with a hollow arrowhead pointing to the general (parent) use case or actor.

Benefits of Use Case Modelling

• Captures Functional Requirements:
  • Ensures all user interactions are considered.
• Facilitates Communication:
  • Provides a clear and understandable model for stakeholders.
• Guides Development:
  • Serves as a basis for design, implementation, and testing.
• Identifies System Boundaries:
  • Clarifies what is inside and outside the scope of the system.

Coding Standards and Code Review Techniques

Coding Standards

Definition

Coding Standards are a set of guidelines and best practices that specify the programming style, practices, and methods for writing code in a particular language.

• Purpose: Ensure code quality, readability, and maintainability across the development team.

Importance

Readability

• Explanation: Consistent code style makes it easier for developers to read and understand each other's code.
• Benefit: Facilitates onboarding new team members and collaborative development.

Maintainability

• Explanation: Well-structured and documented code simplifies debugging and enhancements.
• Benefit: Reduces time and effort required for future modifications.

Consistency

• Explanation: Uniform coding styles across the team prevent confusion.
• Benefit: Promotes a cohesive codebase with predictable patterns.

Error Reduction

• Explanation: Adhering to standards helps avoid common mistakes.
• Benefit: Improves software reliability and reduces defects.

Elements of Coding Standards

Naming Conventions

• Rules for:
  • Variables: Use meaningful names (e.g., customerName).
  • Functions/Methods: Use verbs for actions (e.g., calculateTotal).
  • Classes: Use nouns in PascalCase (e.g., OrderProcessor).

Formatting

• Guidelines on:
  • Indentation: Use spaces or tabs consistently.
  • Braces Placement: Opening brace on the same line or next line.
  • Line Length: Limit lines to a reasonable length (e.g., 80 or 120 characters).

Commenting

• Practices:
  • Document Intent: Explain why, not just what.
  • Function Headers: Describe purpose, parameters, and return values.
  • Inline Comments: Clarify complex logic within code.

Language-Specific Practices

• Examples:
  • Exception Handling: Proper use of try-catch blocks.
  • Resource Management: Closing files and connections.
  • Avoiding Deprecated Features: Use modern, efficient alternatives.

Examples of Coding Standards

Google Style Guides

• Languages Covered: Java, C++, Python, etc.
• Features:
  • Extensive guidelines on style and best practices.
  • Widely adopted in the industry.

PEP 8

• Purpose: Python Enhancement Proposal for Python coding style.
• Key Points:
  • Use 4 spaces per indentation level.
  • Limit lines to 79 characters.
  • Class names in CapWords convention.

MISRA C/C++

• Context: Guidelines for C/C++ in safety-critical systems.
• Focus: Prevent common errors and undefined behaviors.

Code Review Techniques

Purpose of Code Reviews

• Defect Detection: Identify errors before they reach production.
• Ensure Compliance: Verify adherence to coding standards and best practices.
• Knowledge Sharing: Promote learning and cross-training among team members.
• Enhance Code Quality: Improve reliability, performance, and maintainability.

Types of Code Reviews

Formal Inspections

• Process:
  • Defined roles (author, moderator, reviewers).
  • Structured meetings with documented procedures.
• Advantages:
  • Thorough and systematic examination.
• Challenges:
  • Time-consuming.

Walkthroughs

• Process:
  • The author guides reviewers through the code.
  • Focused on understanding the logic.
• Advantages:
  • Collaborative and educational.
• Challenges:
  • Less formal defect detection.

Pair Programming

• Process:
  • Two developers work together at one workstation.
  • One writes code (driver), the other reviews (navigator).
• Advantages:
  • Immediate feedback.
  • High code quality.
• Challenges:
  • Resource-intensive.

Over-the-Shoulder Reviews

• Process:
  • An informal review where a peer reviews code by watching the author's screen.
• Advantages:
  • Quick and easy to arrange.
• Challenges:
  • May miss deeper issues.

Tool-Assisted Reviews

• Process:
  • Use software tools to facilitate code review.
• Advantages:
  • Supports remote teams.
  • Tracks comments and changes.
• Challenges:
  • Depends on tool effectiveness.

Code Review Process

Preparation

• Reviewer Actions:
  • Understand the purpose of the code.
  • Review related documentation.

Reviewing

• Focus Areas:
  • Correctness and logic errors.
  • Compliance with coding standards.
  • Potential security vulnerabilities.
  • Performance considerations.

Feedback

• Guidelines:
  • Be specific about issues.
  • Provide actionable suggestions.
  • Use respectful and constructive language.

Discussion

• Activity: Author and reviewer discuss feedback to clarify points.

Resolution

• Activity: Author makes changes based on the review.

Follow-Up

• Activity: Reviewer verifies that changes address the concerns.

Best Practices

Limit Code Size

• Recommendation: Review code in small chunks (e.g., 200-400 lines).
• Benefit: Improves focus and effectiveness.

Set Clear Objectives

• Approach: Define the scope and goals of the review.
• Benefit: Ensures critical areas receive attention.

Positive Communication

• Guidelines:
  • Use positive language.
  • Acknowledge good practices.
  • Avoid personal criticism.

Timeliness

• Expectation: Reviews should be conducted promptly.
• Benefit: Prevents delays and keeps development moving.

Tools for Code Reviews

Code Review Platforms

GitHub

• Features:
  • Pull Requests for proposing code changes.
  • Inline commenting on code diffs.
• Benefits:
  • Integrates with version control.
  • Supports collaborative review.

GitLab

• Features:
  • Merge Requests with review and approval workflows.
• Benefits:
  • Customizable review processes.
  • Integration with CI/CD pipelines.

Gerrit

• Features:
  • Web-based tool for code review with fine-grained access control.
• Benefits:
  • Scalable for large projects.
  • Supports pre-commit reviews.

Static Analysis Tools

SonarQube

• Purpose: Continuous inspection of code quality.
• Features:
  • Detects bugs, code smells, and security vulnerabilities.
  • Provides dashboards and metrics.

Linting Tools

• Examples:
  • ESLint (JavaScript)
  • Pylint (Python)
• Purpose: Analyze code for stylistic and programming errors.
• Benefits:
  • Enforce coding standards automatically.
  • Provide quick feedback during development.