Pattern-Oriented Software Architecture For Dummies

Book description

Implement programming best practices from the ground up

Imagine how much easier it would be to solve a programming problem, if you had access to the best practices from all the top experts in the field, and you could follow the best design patterns that have evolved through the years. Well, now you can. This unique book offers development solutions ranging from high-level architectural patterns, to design patterns that apply to specific problems encountered after the overall structure has been designed, to idioms in specific programming languages--all in one, accessible, guide. Not only will you improve your understanding of software design, you'll also improve the programs you create and successfully take your development ideas to the next level.

  • Pulls together the best design patterns and best practices for software design into one accessible guide to help you improve your programming projects

  • Helps you avoid re-creating the wheel and also meet the ever-increasing pace of rev cycles, as well as the ever-increasing number of new platforms and technologies for mobile, web, and enterprise computing

  • Fills a gap in the entry-level POSA market, as well as a need for guidance in implementing best practices from the ground up

  • Save time and avoid headaches with your software development projects with Pattern-Oriented Software Architecture For Dummies.

    Note: The ebook version does not provide access to the companion files.

    Table of contents

    1. Cover Page
    2. Title Page
    3. Copyright
    4. About the Author
    5. Dedication
    6. Publisher's Acknowledgments
    7. Contents at a Glance
    8. Table of Contents
    9. Introduction
      1. About This Book
      2. Conventions Used in This Book
      3. What You're Not to Read
      4. Foolish Assumptions
      5. How This Book Is Organized
      6. Icons Used in This Book
      7. Where to Go from Here
    10. Part I: Introducing Software Architecture and Patterns
      1. Chapter 1: Software Architecture Basics
        1. Understanding Software Architecture
        2. Identifying the Problem to Be Solved
        3. Identifying the Requirements
        4. Choosing a Software System Style
      2. Chapter 2: Where Do Architectures Come From?
        1. Understanding Architectural Styles
        2. Creating Software Architecture
      3. Chapter 3: What Do Software Architectures Look Like?
        1. Examining UML Architectural Models
        2. Working with UML Diagrams
        3. Choosing Your Design Tools
        4. Explaining Your Software in an Architecture Document
      4. Chapter 4: Software Pattern Basics
        1. What Patterns Are
        2. What Patterns Are Not
        3. Looking Inside Patterns
        4. Understanding the Patterns Used in This Book
      5. Chapter 5: Seeing How Patterns Are Made and Used
        1. Creating Patterns
        2. Documenting System Architecture with Patterns
    11. Part II: Putting Patterns to Work
      1. Chapter 6: Making Sense of Patterns
        1. Understanding Pattern Classifications
        2. Grouping Patterns
      2. Chapter 7: Building Your Own Pattern Catalog
        1. Assembling Your Catalog
        2. Keeping Your Catalog Current
      3. Chapter 8: Choosing a Pattern
        1. Examining Patterns Critically
        2. Selecting a Particular Pattern
        3. Designing Solution Architecture with Patterns
    12. Part III: Creating Your Application Architecture
      1. Chapter 9: Building Functionality in Layers
        1. Using Layered Architecture
        2. Problem: Designing at Differing Levels
        3. Solution: Layering Your System
      2. Chapter 10: Piping Your Data through Filters
        1. Problem: Analyzing an Image Stream
        2. Solution: Piping through Filters
      3. Chapter 11: Sharing Knowledge and Results on a Blackboard
        1. Problem: Building an Attack Computer
        2. Solution: Building the Blackboard Architecture
      4. Chapter 12: Coordinating Communication through a Broker
        1. Problem: Making Servers Cooperate
        2. Solution: Use a Broker
      5. Chapter 13: Structuring Your Interactive Application with Model-View-Controller
        1. Problem: Looking at Data in Many Ways
        2. Solution: Building a Model-View-Controller System
        3. Seeing Other Ways to Manage Displays
      6. Chapter 14: Layering Interactive Agents with Presentation-Abstraction-Control
        1. Understanding PAC
        2. Problem: Coordinating Interactive Agents
        3. Solution: Creating a Hierarchy of PAC Agents
      7. Chapter 15: Putting Key Functions in a Microkernel
        1. Problem: Hosting Multiple Applications
        2. Solution: Building Essential Functionality in a Microkernel
        3. Examining Microkernel Architecture
      8. Chapter 16: Reflecting and Adapting
        1. Understanding Reflection
        2. Looking for Reflection
        3. Designing Architectural Reflection
        4. Programming Reflection Today
    13. Part IV: Designing with Other POSA Patterns
      1. Chapter 17: Decomposing the System's Structure
        1. Understanding Whole-Part Systems
        2. Implementing the Whole-Part Pattern
      2. Chapter 18: Making a Component the Master
        1. Introducing the Master-Slave Pattern
        2. Implementing Master-Slave
      3. Chapter 19: Controlling Access
        1. Understanding Proxies
        2. Getting Acquainted with Proxy Variants
        3. Implementing a Proxy
      4. Chapter 20: Managing the System
        1. Separating Requests from Execution with Command Processor
        2. Managing Your Views with View Handler
      5. Chapter 21: Enhancing Interprocess Communication
        1. Forwarding Messages to a Receiver
        2. Connecting Client and Server through a Dispatcher
        3. Publishing State Changes to Subscribers
      6. Chapter 22: Counting the Number of References
        1. Problem: Using the Last of Something
        2. Solution: Releasing Resources with the Counted Pointer Idiom
    14. Part V: The Part of Tens
      1. Chapter 23: Ten Patterns You Should Know
        1. Special Case
        2. Do Food
        3. Leaky Bucket Counter
        4. Release Line
        5. Light on Two Sides of Every Room
        6. Streamline Repetition
        7. Observer
        8. Sign-In Continuity
        9. Architect Also Implement
        10. The CHECKS Pattern Language of Information Integrity
      2. Chapter 24: Ten Places to Look for Patterns
        1. A Pattern Language
        2. Pattern-Oriented Software Architecture
        3. Design Patterns
        4. Domain-Driven Design
        5. Pattern Languages of Program Design
        6. Patterns for Time-Triggered Embedded Systems
        7. Software Configuration Management Patterns
        8. Patterns of Enterprise Application Architecture
        10. Apprenticeship Patterns
      3. Chapter 25: Ten Ways to Get Involved with the Pattern Community
        1. Advocate Using Patterns
        2. Write About Your Experiences Using Patterns
        3. Compile a Catalog of Your Work
        4. Mentor Someone
        5. Help Index Patterns
        6. Join a Mailing List
        7. Join a Reading Group
        8. Write Your Own Patterns
        9. Attend a Pattern Conference
        10. Start a Writers' Workshop
    15. Index

    Product information

    • Title: Pattern-Oriented Software Architecture For Dummies
    • Author(s):
    • Release date: January 2013
    • Publisher(s): For Dummies
    • ISBN: 9781119963998