Arquitectura y diseño de software - Guía práctica de patrones de diseño

Idioma

🇺🇸 Inglés

Editorial SAP PRESS

Año / Edición 2025 / 1

Páginas 488

Autores Kristian Köhler

Arquitectura y diseño de software

¡Conozca las herramientas del comercio de software! Comprenda los fundamentos del buen diseño y desarrollo de software, desde los principios orientados a objetos hasta las directrices de código limpio. Una vez que tenga una base sólida, póngase manos a la obra con programas de ejemplo que utilizan arquitectura de software y patrones de diseño como MVC, fábrica, cadena de responsabilidad, adaptador y muchos más. Cada programa le guiará paso a paso a través de un problema, su contexto, su solución y las limitaciones pertinentes. Con información sobre cómo crear una buena documentación e implementar las mejores prácticas, esta completa guía mejorará sus aplicaciones.

Comprender los fundamentos del buen diseño de software.
Domina la arquitectura, el diseño, la organización de aplicaciones, la documentación y mucho más.
Aprenda a utilizar patrones de diseño esenciales siguiendo ejemplos de código detallados.

Aprenderás sobre:

Dominar los fundamentos:
Cree aplicaciones extensibles, fáciles de mantener y de alta calidad con la ayuda de principios y patrones de diseño. Comprenda el buen diseño de software, los principios básicos del desarrollo de software y las herramientas que necesita como desarrollador de software.
Pensar fuera de lo establecido:
Explora diferentes enfoques para lograr un buen diseño de software, independientemente de los patrones de diseño clásicos. Aprende los principios orientados a objetos, define funciones y métodos, garantiza la calidad de tu código con pruebas unitarias y mucho más.
Poner la teoría en práctica:
¡Vea la teoría en acción con numerosos ejemplos de código y modelos de mejores prácticas! Ponga a prueba sus conocimientos resolviendo problemas reales del diseño de software cotidiano y compare sus soluciones con las proporcionadas. Obtenga consejos sobre la documentación y los comentarios en el código fuente.

Aspectos Destacados:

Programación orientada a objetos
Código limpio
Patrones de diseño
Principios de diseño de software
Organización de la solicitud
Patrones de creación
Patrones estructurales
Patrones de comportamiento
Patrones de datos
Patrones de arquitectura de sistemas
Patrones nativos de la nube
Documentación

Ver Tabla de Contenidos Completa

1 Introducción
- 1.1 Paradigmas de programación
  - 1.1.1 Programación estructurada
  - 1.1.2 Programación orientada a objetos
  - 1.1.3 Programación funcional
  - 1.1.4 Programación reactiva
- 1.2 ¿Qué son los patrones de diseño y cómo surgieron?
- 1.3 ¿Qué son la arquitectura de software y el diseño de software?
  - 1.3.1 Tareas de una arquitectura de software
  - 1.3.2 Estilos arquitectónicos y patrones arquitectónicos
- 1.4 La evolución del desarrollo y la arquitectura de software
  - 1.4.1 Tarjetas de clase-responsabilidad-colaboración
  - 1.4.2 Los patrones de la «banda de los cuatro» y su estructura
  - 1.4.3 Código limpio
  - 1.4.4 Desarrollo basado en componentes
  - 1.4.5 Patrones básicos de J2EE
  - 1.4.6 Patrones de integración empresarial
  - 1.4.7 Nube bien diseñada
2 Principios del buen diseño de software
- 2.1 Conceptos básicos de la programación orientada a objetos
  - 2.1.1 Objetos y clases
  - 2.1.2 Encapsulación
  - 2.1.3 Abstracción
  - 2.1.4 Herencia
  - 2.1.5 Polimorfismo
- 2.2 Principios del código limpio
  - 2.2.1 Nombres y convenciones de los identificadores en el código
  - 2.2.2 Definición de funciones y métodos
  - 2.2.3 No te repitas
  - 2.2.4 Establecimiento de límites claros entre los componentes
  - 2.2.5 La teoría de las ventanas rotas y la regla de los Boy Scouts en el software
- 2.3 Principios SOLID
  - 2.3.1 El principio de responsabilidad única
  - 2.3.2 El principio abierto-cerrado
  - 2.3.3 El principio de sustitución de Liskov
  - 2.3.4 El principio de segregación de interfaces
  - 2.3.5 El principio de inversión de dependencias y la inversión de control
- 2.4 Ocultación de información
- 2.5 Inversión de control e inyección de dependencias
- 2.6 Separación de preocupaciones y orientación a aspectos
- 2.7 Garantía de calidad con pruebas unitarias
3 Código fuente y documentación del desarrollo del software
- 3.1 Comentarios en el código fuente
  - 3.1.1 Documentación de interfaces mediante comentarios
  - 3.1.2 Creación de código expresivo
  - 3.1.3 Comentarios necesarios y significativos
  - 3.1.4 No se necesitan comentarios
- 3.2 Documentación de la arquitectura del software
  - 3.2.1 Documentación de las características de calidad
  - 3.2.2 Reglas para una buena documentación de la arquitectura de software
  - 3.2.3 arc42 para la documentación completa
- 3.3 Representación de software en lenguaje de modelado unificado
  - 3.3.1 Diagrama de casos de uso
  - 3.3.2 Diagrama de clases
  - 3.3.3 Diagrama de secuencia
  - 3.3.4 Diagrama de estados
  - 3.3.5 Diagrama de componentes
- 3.4 Modelo C4 para representar la arquitectura de software
  - 3.4.1 Contexto del sistema (Nivel 1 o C1)
  - 3.4.2 Contenedor (Nivel 2 o C2)
  - 3.4.3 Componente (Nivel 3 o C3)
  - 3.4.4 Código (Nivel 4 o C4)
- 3.5 Documento como código
  - 3.5.1 AsciiDoc
  - 3.5.2 PlantUML
  - 3.5.3 Structurizr
4 Patrones de software
- 4.1 Método de fábrica
  - 4.1.1 Problema y motivación
  - 4.1.2 Solución
  - 4.1.3 Solución de muestra
  - 4.1.4 Cuándo utilizar el patrón
  - 4.1.5 Consecuencias
  - 4.1.6 Ejemplo real en software de código abierto
- 4.2 Constructor
  - 4.2.1 Problema y motivación
  - 4.2.2 Solución
  - 4.2.3 Solución de muestra
  - 4.2.4 Cuándo utilizar el patrón
  - 4.2.5 Consecuencia
  - 4.2.6 Ejemplo real en software de código abierto
- 4.3 Estrategia
  - 4.3.1 Problema y motivación
  - 4.3.2 Solución
  - 4.3.3 Solución de muestra
  - 4.3.4 Cuándo utilizar el patrón
  - 4.3.5 Consecuencias
  - 4.3.6 Ejemplo del mundo real
- 4.4 Cadena de responsabilidad
  - 4.4.1 Problema y motivación
  - 4.4.2 Solución
  - 4.4.3 Solución de muestra
  - 4.4.4 Cuándo utilizar el patrón
  - 4.4.5 Consecuencias
  - 4.4.6 Ejemplo del mundo real
- 4.5 Comando
  - 4.5.1 Problema y motivación
  - 4.5.2 Solución
  - 4.5.3 Solución de muestra
  - 4.5.4 Cuándo utilizar el patrón
  - 4.5.5 Consecuencias
  - 4.5.6 Ejemplo del mundo real
- 4.6 Observador
  - 4.6.1 Problema y motivación
  - 4.6.2 Solución
  - 4.6.3 Solución de muestra
  - 4.6.4 Cuándo utilizar el patrón
  - 4.6.5 Consecuencias
  - 4.6.6 Ejemplo del mundo real
- 4.7 Singleton
  - 4.7.1 Problema y motivación
  - 4.7.2 Solución
  - 4.7.3 Solución de muestra
  - 4.7.4 Cuándo utilizar el patrón
  - 4.7.5 Consecuencias
  - 4.7.6 Ejemplo del mundo real
- 4.8 Adaptador/Envoltura
  - 4.8.1 Problema y motivación
  - 4.8.2 Solución
  - 4.8.3 Solución de muestra
  - 4.8.4 Cuándo utilizar el patrón
  - 4.8.5 Consecuencias
  - 4.8.6 Ejemplo del mundo real
- 4.9 Iterador
  - 4.9.1 Problema y motivación
  - 4.9.2 Solución
  - 4.9.3 Solución de muestra
  - 4.9.4 Cuándo utilizar el patrón
  - 4.9.5 Consecuencias
  - 4.9.6 Ejemplo del mundo real
- 4.10 Compuesto
  - 4.10.1 Problema y motivación
  - 4.10.2 Solución
  - 4.10.3 Solución de muestra
  - 4.10.4 Cuándo utilizar el patrón
  - 4.10.5 Consecuencias
  - 4.10.6 Ejemplo del mundo real
- 4.11 El concepto de antipatrones
  - 4.11.1 Gran bola de lodo
  - 4.11.2 Objeto Dios
  - 4.11.3 Código espagueti
  - 4.11.4 Reinventando la rueda
  - 4.11.5 Programación del culto a la carga
5 Arquitectura, estilos y patrones de software
- 5.1 El papel del arquitecto de software
- 5.2 Estilos de arquitectura de software
  - 5.2.1 Arquitectura cliente-servidor
  - 5.2.2 Arquitectura en capas y capas de servicio
  - 5.2.3 Arquitectura basada en eventos
  - 5.2.4 Arquitectura de microkernel o arquitectura de complementos
  - 5.2.5 Microservicios
- 5.3 Estilos para la organización de aplicaciones y la estructura del código
  - 5.3.1 Diseño basado en el dominio
  - 5.3.2 Diseños estratégicos y tácticos
  - 5.3.3 Arquitectura hexagonal/Puertos y adaptadores
  - 5.3.4 Arquitectura limpia
- 5.4 Patrones para el soporte de estilos arquitectónicos
  - 5.4.1 Patrón Modelo-Vista-Controlador
  - 5.4.2 Patrón Modelo-Vista-VistaModelo
  - 5.4.3 Objetos de transferencia de datos
  - 5.4.4 Patrón de fachada remota
6 Comunicación entre servicios
- 6.1 Estilos de comunicación de aplicaciones
  - 6.1.1 Comunicación sincrónica
  - 6.1.2 Comunicación asíncrona y mensajería
  - 6.1.3 Transmisión en tiempo real
- 6.2 Patrones de resiliencia
  - 6.2.1 Propagación de errores
  - 6.2.2 Subdivisión de los patrones de resiliencia
  - 6.2.3 Patrón de tiempo de espera
  - 6.2.4 Patrón de reintento
  - 6.2.5 Patrón del interruptor automático
  - 6.2.6 Patrón de mamparo
  - 6.2.7 Patrón de estado estacionario
- 6.3 Patrones de mensajería
  - 6.3.1 Conceptos de mensajería
  - 6.3.2 Patrones de canales de mensajería
  - 6.3.3 Patrones de construcción de mensajes
  - 6.3.4 Patrón de punto final de mensajería
- 6.4 Patrones para el control de versiones de interfaces
  - 6.4.1 Punto final para el patrón de versión
  - 6.4.2 Referencia al patrón de mensaje
  - 6.4.3 Patrón de mensaje autónomo
  - 6.4.4 Mensaje con metadatos de referencia
  - 6.4.5 Mensaje con metadatos autodescriptivos
7 patrones y conceptos para aplicaciones distribuidas
- 7.1 Coherencia
- 7.2 El teorema CAP
- 7.3 El teorema PACELC
- 7.4 Consistencia eventual
- 7.5 Patrón de arquitectura sin estado
  - 7.5.1 Problema y motivación
  - 7.5.2 Solución
  - 7.5.3 Solución de muestra
  - 7.5.4 Cuándo utilizar el patrón
  - 7.5.5 Consecuencias
- 7.6 Base de datos por patrón de servicio
  - 7.6.1 Problema y motivación
  - 7.6.2 Solución
  - 7.6.3 Solución de muestra
  - 7.6.4 Cuándo utilizar el patrón
  - 7.6.5 Consecuencias
- 7.7 Patrón de bloqueo optimista
  - 7.7.1 Problema y motivación
  - 7.7.2 Solución
  - 7.7.3 Solución de muestra
  - 7.7.4 Cuándo utilizar el patrón
  - 7.7.5 Consecuencias
  - 7.7.6 Bloqueo pesimista
- 7.8 Patrón Saga: el patrón de transacciones distribuidas
  - 7.8.1 Problema y motivación
  - 7.8.2 Solución
  - 7.8.3 Solución de muestra
  - 7.8.4 Cuándo utilizar el patrón
  - 7.8.5 Consecuencias
- 7.9 Patrón de bandeja de salida transaccional
  - 7.9.1 Problema y motivación
  - 7.9.2 Solución
  - 7.9.3 Solución de muestra
  - 7.9.4 Cuándo utilizar el patrón
  - 7.9.5 Consecuencias
- 7.10 Patrón de abastecimiento de eventos
  - 7.10.1 Problema y motivación
  - 7.10.2 Solución
  - 7.10.3 Solución de muestra
  - 7.10.4 Cuándo utilizar el patrón
  - 7.10.5 Consecuencias
- 7.11 Patrón de segregación de responsabilidades de comando y consulta
  - 7.11.1 Problema y motivación
  - 7.11.2 Solución
  - 7.11.3 Solución de muestra
  - 7.11.4 Cuándo utilizar el patrón
  - 7.11.5 Consecuencias
- 7.12 Patrón de rastreo distribuido
  - 7.12.1 Problema y motivación
  - 7.12.2 Solución
  - 7.12.3 Solución de muestra
  - 7.12.4 Cuándo utilizar el patrón
  - 7.12.5 Consecuencias
El autor
Índice

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

ℹ️ ¿Cómo adquirir este libro?

Este producto tiene un precio especial bajo consulta. Puedes iniciar tu pedido o aclarar cualquier duda en el botón Consultar precio de la página.

También hemos preparado una guía paso a paso para explicarte cómo solicitar tu cotización fácilmente.

Ver paso a paso aquí →

Descargo de responsabilidad

SAP, otros productos SAP y servicios mencionados aquí así como sus respectivos logos son marca registrada de SAP SE (o una compañía afiliada de SAP) en Alemania y otros países. Nuestra compañía no está afiliada con SAP SE ni con ninguna de sus compañías afiliadas incluyendo pero no limitada a: Sybase, Business Objects, Hybris, Ariba y SuccessFactors. Todos los otros nombres, marcas, logos, etc. son marcas o servicios registrados de sus respectivos propietarios.

Inicio > Libros SAP > Libros en Inglés > Arquitectura y diseño de software - Guía práctica de patrones de diseño

Arquitectura y diseño de software - Guía práctica de patrones de diseño

Name: Arquitectura y diseño de software - Guía práctica de patrones de diseño
Brand: SAP
SKU: BOOK-SAPPRESS-EBOOK-2025-9781493227440

Garantía

Recibe el producto que esperabas o te devolvemos tu dinero

Envío gratis

Envío gratis a tu cuenta de correo electrónico

¿Desea una muestra de un curso/libro?

Necesita una muestra de un curso/libro, solicítela en el chat de abajo y se la brindamos con gusto.

1 mes de $0.00 USD sin intereses		Total $0.00 USD
2 meses de $0.00 USD sin intereses		Total $0.00 USD
3 meses de $0.00 USD sin intereses		Total $0.00 USD
4 meses de $0.00 USD sin intereses		Total $0.00 USD
5 meses de $0.00 USD sin intereses		Total $0.00 USD
6 meses de $0.00 USD sin intereses		Total $0.00 USD