1st Edition

Software Engineering Design Theory and Practice

By Carlos Otero Copyright 2012
    368 Pages 60 B/W Illustrations
    by Auerbach Publications

    Taking a learn-by-doing approach, Software Engineering Design: Theory and Practice uses examples, review questions, chapter exercises, and case study assignments to provide students and practitioners with the understanding required to design complex software systems. Explaining the concepts that are immediately relevant to software designers, it begins with a review of software design fundamentals.

    The text presents a formal top-down design process that consists of several design activities with varied levels of detail, including the macro-, micro-, and construction-design levels. As part of the top-down approach, it provides in-depth coverage of applied architectural, creational, structural, and behavioral design patterns. For each design issue covered, it includes a step-by-step breakdown of the execution of the design solution, along with an evaluation, discussion, and justification for using that particular solution.

    The book outlines industry-proven software design practices for leading large-scale software design efforts, developing reusable and high-quality software systems, and producing technical and customer-driven design documentation. It also:

    • Offers one-stop guidance for mastering the Software Design & Construction sections of the official Software Engineering Body of Knowledge (SWEBOK®)
    • Details a collection of standards and guidelines for structuring high-quality code
    • Describes techniques for analyzing and evaluating the quality of software designs

    Collectively, the text supplies comprehensive coverage of the software design concepts students will need to succeed as professional design leaders. The section on engineering leadership for software designers covers the necessary ethical and leadership skills required of software developers in the public domain. The section on creating software design documents (SDD) familiarizes students with the software design notations, structural descriptions, and behavioral models required for SDDs.

    Course notes, exercises with answers, online resources, and an instructor’s manual are available upon qualified course adoption. Instructors can contact the author about these resources via the author's website: http://softwareengineeringdesign.com/

    Introduction to Software Engineering Design
    Engineering Design
    Engineering Problem Solving
         Initial State
         Operational State
              Thinking about the Problem
              Problem Solution
         Goal State
    Software Engineering Design
    Why Study Software Engineering Design?
         Reasons for Studying Software Design in Product Development
         Reasons for Studying Software Design in Project Management
    Software Design Challenges
         Design Challenge 1: Requirements Volatility
         Design Challenge 2: Process
         Design Challenge 3: Technology
         Design Challenge 4: Ethical and Professional Practices
         Design Challenge 5: Managing Design Influences
              Stakeholders
              Development Organization’s Structure
    Context of Software Design
    Software Design Process
         Software Architecture
         Detailed Design
              Interface Design
              Component Design
    Construction Design
    Human–Computer Interface Design
    Software Design Documentation
    Software Design Management
    Roles of the Software Designer
         Systems Engineer
         Software Architect
         Component Designer
    Software Design Fundamentals
         General Software Design Principles
              Modularization
              Abstraction
              Encapsulation
              Coupling
              Cohesion
              Separation of Interface and Implementation
              Completeness and Sufficiency
    Practical Software Design Considerations
         Design for Minimizing Complexity
         Design for Change
    Software Design Strategies
         Structured Design
         Object-Oriented Design

    Software Design with Unified Modeling Language
    What Is UML?
    Why Study UML?
    The UML’s Fundamentals
    Structural Modeling
    Component Diagrams
         Logical versus Physical Components
    Class Diagrams
         Classes
              Name Compartment
              Attribute Compartment
              Operation Compartment
    Relationships
         Dependency
         Association
         Aggregation
         Composition
         Generalization
         Realization
    Deployment Diagrams
    Behavioral Modeling
    Use Case Diagrams
    Interaction Diagrams
         Communication Diagrams
         Sequence Diagrams
         Concurrency in Interaction Diagrams

    Principles of Software Architecture
    What Is Software Architecture?
    Why Study Software Architecture?
    Key Tasks in Architectural Design
         Identifying Stakeholders’ Concerns
         Identifying Appropriate Architectural Views
         Identifying Architectural Styles and Patterns
         Identifying System Interfaces
         Identifying Impact of Architectural Decisions in Organization
              Impact on Customer Base
              Impact on Budget and Schedule
              Impact from Resource Availability
         Identifying the System’s Major Components and Interfaces
         Evaluating and Validating the Architecture
         Introducing Policies for Design Synchronicity
    Problem Solving in Software Architecture
         Inputs
         Constraints
         Outputs
    Software Architecture Process
    Understand and Evaluate Requirements
         Elicitation
              Requirement Sources
              Elicitation Techniques
         Analysis
         Specification and Validation
              Specific
              Correct
              Complete
              Consistent
              Attainable
              Verifiable
    Designing the Architecture
         The 4 + 1 View Model
              User View
              Process View
              Physical View
              Development View
              Logical View
         Components and Connectors
         Designing Logical Architectural Elements Using Data Flows
         Designing Logical Architectural Elements Using Styles and Patterns
         Designing the Process Architecture
              Processes
              Threads
    Evaluating the Architecture

    Patterns and Styles in Software Architecture
    Architectural Styles and Patterns
         History of Architectural Styles and Patterns
         Architectural Pattern Classification
    Data-Centered Systems
         Blackboard Pattern
    Data Flow Systems
         Pipe and Filter Pattern
    Distributed Systems
         Client–Server Pattern
         Broker Pattern
    Interactive Systems
         Model–View–Controller Pattern
    Hierarchical Systems
         Main Program and Subroutine
         Layered Pattern

    Principles of Detailed Design
    What Is Detailed Design?
    Key Tasks in Detailed Design
    Detailed Design Process
    Understanding the Architecture and Requirements
    Creating Detailed Designs
         Interface Design
              External Interface Design
              Internal Interface Design
              Graphical User Interface Design
         Designing Internal Structure of Components
         Classes
         Interfaces, Types, Subtypes, Dynamic Binding, and Polymorphism
         Objects
    Design Principles for Internal Component Design
         Open–Closed Principle
         Liskov Substitution Principle
         Interface Segregation Principle
    Programming Styles in Detailed Design
         Function Names
         Variable Names
    Modeling Internal Behavior of Components
    Design Components Using Design Patterns
         Architectural versus Design Patterns
         Classification of Design Patterns
         Documenting Design Patterns
    Document the Software Design
         Interface Control Document
         Software Version Document
    Monitor and Control Implementation

    Creational Design Patterns in Detailed Design
    Creational Design Patterns
    Abstract Factory
         Problem
         Structure
         Implementation
         Benefits
    Factory Method
         Problem
         Structure
         Implementation
         Benefits
    Builder
         Problem
         Structure
         Implementation
         Benefits
    Prototype
         Problem
         Structure
         Implementation
         Benefits
    Singleton
         Problem
         Structure
         Implementation
         Benefits

    Structural and Behavioral Patterns in Detailed Design
    Structural Design Patterns
    Adapter
         Problem
         Structure
         Implementation
         Benefits
    Composite
         Problem
         Structure
         Implementation
         Benefits
    Facade
         Problem
         Structure
         Implementation
         Benefits
    Behavioral Design Patterns
    Iterator
         Problem
         Structure
         Implementation
         Benefits
    Observer
         Problem
         Structure
         Implementation
         Benefits

    Principles of Construction Design
    What Is Construction Design?
    Why Study Construction Design?
    Behavioral Construction Design
         Flow-Based Designs
         State-Based Designs
         Table-Based Designs
              Limited-Entry Decision Table
              Extended-Entry Decision Table
              Mixed-Entry Decision Table
              Table-Based Construction
         Programming Design Language
    Software Construction Using Styles
         Formatting Conventions
              Indentation
              Brace Placement
    Naming Conventions
    Documentation Conventions
         Documenting Files
         Documenting Functions
    Minimizing Complexity in Construction Design
    Quality Evaluation of Construction Design
         Peer Reviews
         Unit Testing
         Cyclomatic Complexity

    Human–Computer Interface Design; Jacob Somervell
    What Is Human–Computer Interface Design?
    Why Study Human–Computer Interface Design?
    General HCI Design Principles
    Human–Computer Interface Design Methods
         Getting Started
         Fidelity in Prototypes
         Metaphors
         Gestalt Principles
         Reusing Earlier Designs
    Evaluation of HCI Quality
         Usability Testing
         Analytic Testing
         Empirical Testing

    Software Design Management, Leadership, and Ethics; Luis Daniel Otero
    What Is Software Design Management?
    Why Study Design Management?
    The Concept of Quality
    Design Management Framework
    Planning Design Efforts
         Scoping
              Work Breakdown Structure
              Budgeting
         Organizing
              Linear Responsibility Chart
              Scheduling with Gantt Charts and Network Diagrams
              Probability of Time to Completion
         Establish Change Control Policy
    Implementation Phase
         Earned Value Management
    Termination Stage
    Leading the Design Effort
         Personality Traits and Leadership
         Personality Dimensions
         Traits of Effective Leaders
         Ethical Leadership
         Power
    Key Leadership Skills
         Communication Skills
         Networking Skills
         Motivation Skills
         Negotiation Skills
    Ethics in Software Design
         Public and Product Principles
         Judgment Principle
         Management Principle

    Index

    Each chapter includes chapter objectives, a conceptual overview, summary , exercises, and references

    Biography

    Carlos E. Otero, PhD, is assistant professor in the College of Technology and Innovation at the University of South Florida (USF). Prior to joining USF, Dr. Otero worked as assistant professor of software engineering in the Department of Mathematics and Computer Science at the University of Virginia, College at Wise, where he created the software engineering design course for Virginia’s first and (at the time of writing) only EAC/ABET-accredited BS in software engineering.

    Prior to his academic career, Dr. Otero spent 11 years in the private industry, where he worked as design and development engineer in a wide variety of military computer systems, including satellite communications systems, command and control systems, wireless security systems, and unmanned aerial vehicle systems. Currently, he continues to consult with industry in the areas of requirements engineering, software systems analysis, design and development, quality assurance, and systems engineering.

    Dr. Otero received his BS in computer science, MS in software engineering, MS in systems engineering, and PhD in computer engineering from Florida Institute of Technology in Melbourne. He has published over 35 technical publications in scientific peer-reviewed journals and conferences proceedings. He is a senior member of the Institute of Electrical and Electronics Engineers (IEEE), an active professional member of the Association for Computing Machinery (ACM), and a member of several journal editorial boards in technology and engineering.

    … intended for use as a textbook for an advanced course in software design. Each chapter ends with review questions and references. … provides an overview of the software development process, something that would not be out of line in a course on software engineering including such topics as software process, software management, balancing conflicting values of stakeholders, testing, quality, and ethics. The author has principally focused on software design though, extracting the design phase from the surrounding software development lifecycle. … Software design strategies are addressed, including structured, functional, and object oriented design. There’s also a chapter on UML (Unified Modeling Language). UML is a set of design paradigms (and tools) used for design modeling, and examples are provided throughout. … The author also provides coded examples of UML diagrams in C++ and Java. … To sum up, the intent of this book is educational on the topic of software design with emphasis on UML, software patterns and object oriented programming. There is also enough software engineering material that makes this text also appropriate for use in a software engineering, object oriented or software patterns lab course.
    —Robert Schaefer, Research Engineer, MIT Haystack Observatory, writing in the New York Journal of Books