Software Architecture and Design - The Practical Guide to Design Patterns

Language

🇺🇸 English

Publisher SAP PRESS

Year / Edition 2025 / 1

Pages 488

Authors Kristian Köhler

Software Architecture and Design

Get to know the tools of the software trade! Understand the fundamentals of good software design and development, from object-oriented principles to clean code guidelines. Once you have a solid foundation, get your hands dirty with sample programs that use software architecture and design patterns like MVC, factory, chain of responsibility, adapter, and many more. Every program will walk you step by step through a problem, its context, its solution, and relevant limitations. With information on creating good documentation and implementing best practices, this comprehensive guide will improve your applications!

Understand the fundamentals of good software design
Master architecture, design, application organization, documentation, and more
Learn to use essential design patterns by following detailed code examples

You'll learn about:

Mastering Fundamentals:
Create extensible, maintainable, and high-quality applications with the help of design principles and patterns. Understand good software design, the basic principles of software development, and the tools you need as a software developer.
Thinking Outside the Box:
Walk through approaches to achieve good software design—independent of classic design patterns. Learn about object-oriented principles, define functions and methods, ensure the quality of your code with unit tests, and more.
Putting Theory into Practice:
See theory in action with numerous code examples and best practice models! Test your understanding by working through realistic problems from everyday software design and compare your solutions to those provided. Get tips on documentation and comments in the source code.

Key Highlights:

Object-oriented programming
Clean code
Design patterns
Software design principles
Application organization
Creation patterns
Structural patterns
Behavioral patterns
Data patterns
System architecture patterns
Cloud-native patterns
Documentation

View Full Table of Contents

1 Introduction
- 1.1 Programming Paradigms
  - 1.1.1 Structured Programming
  - 1.1.2 Object-Oriented Programming
  - 1.1.3 Functional Programming
  - 1.1.4 Reactive Programming
- 1.2 What Are Design Patterns and How Did They Come About?
- 1.3 What Are Software Architecture and Software Design?
  - 1.3.1 Tasks of a Software Architecture
  - 1.3.2 Architectural Styles and Architectural Patterns
- 1.4 The Evolution of Software Development and Architecture
  - 1.4.1 Class-Responsibility-Collaboration Cards
  - 1.4.2 The “Gang of Four” Patterns and Their Structure
  - 1.4.3 Clean Code
  - 1.4.4 Component-Based Development
  - 1.4.5 Core J2EE Patterns
  - 1.4.6 Enterprise Integration Patterns
  - 1.4.7 Well-Architected Cloud
2 Principles of Good Software Design
- 2.1 Basic Concepts of Object-Oriented Programming
  - 2.1.1 Objects and Classes
  - 2.1.2 Encapsulation
  - 2.1.3 Abstraction
  - 2.1.4 Inheritance
  - 2.1.5 Polymorphism
- 2.2 Clean Code Principles
  - 2.2.1 Identifier Names and Conventions in the Code
  - 2.2.2 Defining Functions and Methods
  - 2.2.3 Don’t Repeat Yourself
  - 2.2.4 Establishing Clear Boundaries Between Components
  - 2.2.5 The Broken Windows Theory and the Boy Scout Rule in Software
- 2.3 SOLID Principles
  - 2.3.1 The Single Responsibility Principle
  - 2.3.2 The Open-Closed Principle
  - 2.3.3 The Liskov Substitution Principle
  - 2.3.4 The Interface Segregation Principle
  - 2.3.5 The Dependency Inversion Principle and the Inversion of Control
- 2.4 Information Hiding
- 2.5 Inversion of Control and Dependency Injection
- 2.6 Separation of Concerns and Aspect Orientation
- 2.7 Quality Assurance with Unit Tests
3 Source Code and Documenting the Software Development
- 3.1 Comments in the Source Code
  - 3.1.1 Documenting Interfaces Using Comments
  - 3.1.2 Creating Expressive Code
  - 3.1.3 Necessary and Meaningful Comments
  - 3.1.4 Comments Not Needed
- 3.2 Documenting the Software Architecture
  - 3.2.1 Documenting Quality Features
  - 3.2.2 Rules for Good Software Architecture Documentation
  - 3.2.3 arc42 for the Complete Documentation
- 3.3 Representing Software in Unified Modeling Language
  - 3.3.1 Use Case Diagram
  - 3.3.2 Class Diagram
  - 3.3.3 Sequence Diagram
  - 3.3.4 State Diagram
  - 3.3.5 Component Diagram
- 3.4 C4 Model for Representing Software Architecture
  - 3.4.1 System Context (Level 1 or C1)
  - 3.4.2 Container (Level 2 or C2)
  - 3.4.3 Component (Level 3 or C3)
  - 3.4.4 Code (Level 4 or C4)
- 3.5 Doc-as-Code
  - 3.5.1 AsciiDoc
  - 3.5.2 PlantUML
  - 3.5.3 Structurizr
4 Software Patterns
- 4.1 Factory Method
  - 4.1.1 Problem and Motivation
  - 4.1.2 Solution
  - 4.1.3 Sample Solution
  - 4.1.4 When To Use the Pattern
  - 4.1.5 Consequences
  - 4.1.6 Real-World Example in Open-Source Software
- 4.2 Builder
  - 4.2.1 Problem and Motivation
  - 4.2.2 Solution
  - 4.2.3 Sample Solution
  - 4.2.4 When To Use the Pattern
  - 4.2.5 Consequence
  - 4.2.6 Real-World Example in Open-Source Software
- 4.3 Strategy
  - 4.3.1 Problem and Motivation
  - 4.3.2 Solution
  - 4.3.3 Sample Solution
  - 4.3.4 When To Use the Pattern
  - 4.3.5 Consequences
  - 4.3.6 Real-World Example
- 4.4 Chain of Responsibility
  - 4.4.1 Problem and Motivation
  - 4.4.2 Solution
  - 4.4.3 Sample Solution
  - 4.4.4 When To Use the Pattern
  - 4.4.5 Consequences
  - 4.4.6 Real-World Example
- 4.5 Command
  - 4.5.1 Problem and Motivation
  - 4.5.2 Solution
  - 4.5.3 Sample Solution
  - 4.5.4 When To Use the Pattern
  - 4.5.5 Consequences
  - 4.5.6 Real-World Example
- 4.6 Observer
  - 4.6.1 Problem and Motivation
  - 4.6.2 Solution
  - 4.6.3 Sample Solution
  - 4.6.4 When To Use the Pattern
  - 4.6.5 Consequences
  - 4.6.6 Real-World Example
- 4.7 Singleton
  - 4.7.1 Problem and Motivation
  - 4.7.2 Solution
  - 4.7.3 Sample Solution
  - 4.7.4 When To Use the Pattern
  - 4.7.5 Consequences
  - 4.7.6 Real-World Example
- 4.8 Adapter/Wrapper
  - 4.8.1 Problem and Motivation
  - 4.8.2 Solution
  - 4.8.3 Sample Solution
  - 4.8.4 When To Use the Pattern
  - 4.8.5 Consequences
  - 4.8.6 Real-World Example
- 4.9 Iterator
  - 4.9.1 Problem and Motivation
  - 4.9.2 Solution
  - 4.9.3 Sample Solution
  - 4.9.4 When To Use the Pattern
  - 4.9.5 Consequences
  - 4.9.6 Real-World Example
- 4.10 Composite
  - 4.10.1 Problem and Motivation
  - 4.10.2 Solution
  - 4.10.3 Sample Solution
  - 4.10.4 When To Use the Pattern
  - 4.10.5 Consequences
  - 4.10.6 Real-World Example
- 4.11 The Concept of Anti-Patterns
  - 4.11.1 Big Ball of Mud
  - 4.11.2 God Object
  - 4.11.3 Spaghetti Code
  - 4.11.4 Reinventing the Wheel
  - 4.11.5 Cargo Cult Programming
5 Software Architecture, Styles, and Patterns
- 5.1 The Role of the Software Architect
- 5.2 Software Architecture Styles
  - 5.2.1 Client-Server Architecture
  - 5.2.2 Layered Architecture and Service Layers
  - 5.2.3 Event-Driven Architecture
  - 5.2.4 Microkernel Architecture or Plugin Architecture
  - 5.2.5 Microservices
- 5.3 Styles for Application Organization and Code Structure
  - 5.3.1 Domain-Driven Design
  - 5.3.2 Strategic and Tactical Designs
  - 5.3.3 Hexagonal Architecture/Ports and Adapters
  - 5.3.4 Clean Architecture
- 5.4 Patterns for the Support of Architectural Styles
  - 5.4.1 Model View Controller Pattern
  - 5.4.2 Model View ViewModel Pattern
  - 5.4.3 Data Transfer Objects
  - 5.4.4 Remote Facade Pattern
6 Communication Between Services
- 6.1 Styles of Application Communication
  - 6.1.1 Synchronous Communication
  - 6.1.2 Asynchronous Communication and Messaging
  - 6.1.3 Streaming
- 6.2 Resilience Patterns
  - 6.2.1 Error Propagation
  - 6.2.2 Subdivision of the Resilience Patterns
  - 6.2.3 Timeout Pattern
  - 6.2.4 Retry Pattern
  - 6.2.5 Circuit Breaker Pattern
  - 6.2.6 Bulkhead Pattern
  - 6.2.7 Steady State Pattern
- 6.3 Messaging Patterns
  - 6.3.1 Messaging Concepts
  - 6.3.2 Messaging Channel Patterns
  - 6.3.3 Message Construction Patterns
  - 6.3.4 Messaging Endpoint Pattern
- 6.4 Patterns for Interface Versioning
  - 6.4.1 Endpoint for Version Pattern
  - 6.4.2 Referencing Message Pattern
  - 6.4.3 Self-Contained Message Pattern
  - 6.4.4 Message with Referencing Metadata
  - 6.4.5 Message with Self-Describing Metadata
7 Patterns and Concepts for Distributed Applications
- 7.1 Consistency
- 7.2 The CAP Theorem
- 7.3 The PACELC Theorem
- 7.4 Eventual Consistency
- 7.5 Stateless Architecture Pattern
  - 7.5.1 Problem and Motivation
  - 7.5.2 Solution
  - 7.5.3 Sample Solution
  - 7.5.4 When To Use the Pattern
  - 7.5.5 Consequences
- 7.6 Database per Service Pattern
  - 7.6.1 Problem and Motivation
  - 7.6.2 Solution
  - 7.6.3 Sample Solution
  - 7.6.4 When To Use the Pattern
  - 7.6.5 Consequences
- 7.7 Optimistic Locking Pattern
  - 7.7.1 Problem and Motivation
  - 7.7.2 Solution
  - 7.7.3 Sample Solution
  - 7.7.4 When To Use the Pattern
  - 7.7.5 Consequences
  - 7.7.6 Pessimistic Locking
- 7.8 Saga Pattern: The Distributed Transactions Pattern
  - 7.8.1 Problem and Motivation
  - 7.8.2 Solution
  - 7.8.3 Sample Solution
  - 7.8.4 When To Use the Pattern
  - 7.8.5 Consequences
- 7.9 Transactional Outbox Pattern
  - 7.9.1 Problem and Motivation
  - 7.9.2 Solution
  - 7.9.3 Sample Solution
  - 7.9.4 When To Use the Pattern
  - 7.9.5 Consequences
- 7.10 Event Sourcing Pattern
  - 7.10.1 Problem and Motivation
  - 7.10.2 Solution
  - 7.10.3 Sample Solution
  - 7.10.4 When To Use the Pattern
  - 7.10.5 Consequences
- 7.11 Command Query Responsibility Segregation Pattern
  - 7.11.1 Problem and Motivation
  - 7.11.2 Solution
  - 7.11.3 Sample Solution
  - 7.11.4 When To Use the Pattern
  - 7.11.5 Consequences
- 7.12 Distributed Tracing Pattern
  - 7.12.1 Problem and Motivation
  - 7.12.2 Solution
  - 7.12.3 Sample Solution
  - 7.12.4 When To Use the Pattern
  - 7.12.5 Consequences
The Author
Index

ℹ️ How to purchase this book?

This product has a special price upon request. You can start your order or clarify any doubts using the Contact for Price button on the page.

We have also prepared a step-by-step guide to explain how to easily request your quote.

Read the guide here →

Disclaimer

SAP, other SAP products and services mentioned herein as well as their respective logos are trademarks or registered trademarks of SAP SE (or an SAP affiliate company) in Germany and other countries. Our Company is not affiliated to SAP SE or any of its affiliated companies including but not limited to: Sybase, Business Objects, Hybris, Ariba and SuccessFactors. All other names, brands, logos, etc. are registered trade or service marks of their respective owners.

Home > SAP Books > English Books > Software Architecture and Design - The Practical Guide to Design Patterns

Software Architecture and Design - The Practical Guide to Design Patterns

Name: Software Architecture and Design - The Practical Guide to Design Patterns
Brand: SAP
SKU: BOOK-SAPPRESS-EBOOK-2025-9781493227440

Warranty

Receive the product you were expecting or we will refund your money

Free shipping

Free shipping to your email

Would you like a sample course/book?

If you need a sample of a course/book, request it in the chat below and we will be happy to provide it to you.

1 installment of $0.00 USD without interest		Total $0.00 USD
2 installments of $0.00 USD without interest		Total $0.00 USD
3 installments of $0.00 USD without interest		Total $0.00 USD
4 installments of $0.00 USD without interest		Total $0.00 USD
5 installments of $0.00 USD without interest		Total $0.00 USD
6 installments of $0.00 USD without interest		Total $0.00 USD