Software architecture deep dive

What better place to take a deep dive into software architecture than at SDD Deep Dive conference? This technology and platform agnostic 3-day workshop places a heavy emphasis on distributed, modular architectures (including Microservices), and dives deep into the architectural aspects of dealing with architectural modularity, distributed data, migration paths for breaking up monolithic applications, service communication patterns, caching patterns, performance patterns, configuration patterns, and application integration strategies.

Moving from the monolithic application world most of us are used to a highly distributed world is very challenging. In this workshop you will learn how to overcome most of the challenges associated with distributed applications and distributed data. Knowing that everything is not always about technology, we’ll also take a look at some of the organizational change associated with embracing architectural modularity, and see techniques for reorganizing teams to enable companies to achieve a high level of architectural modularity.

Throughout the workshop you’ll be doing hands-on architecture katas (exercises) to apply some of the techniques learned in some of the topics. While I will be showing a few examples using Java, the code and patterns can be applied to C#/.NET just as well.

We’ll also spend some time doing some real-time architecture analysis, so if you’re able to bring along architecture diagrams and if possible the codebase for a current project on your laptop, that would be great.

If that isn’t possible (e.g. for security/confidentiality reasons), don’t worry as we’ll have some examples available for you to work on – so please bring a laptop if you can.

What you’ll learn in the class:

Architectural Modularity

  • Why the hype?
  • Drivers for modularity
  • Technology drivers
  • Business drivers
  • Distributed Architecture Challenges

Modular Architecture Styles

  • Focus: Adaptability and Replaceability
  • Pipeline architecture
  • Microkernel architecture
  • Modular monolith architecture
  • Microservices architecture
  • Service-Based architecture
  • Event-Driven architecture

Migration Patterns and Paths

  • Architecture analysis and component identification
  • Flattening and refactoring components
  • Managing component dependencies
  • Identifying component domains
  • Splitting up a user interface
  • Moving to macro services
  • Service identification techniques
  • Moving to microservices

Event-Driven Services

  • Asynchronous processing
  • Asynchronous error handling
  • Request/reply messaging
  • Broadcast messaging
  • Transactional messaging
  • Apache Kafka vs. standard messaging

Data and Caching Patterns

  • Leveraging caching in Microservices
  • Distributed caching techniques
  • Replicated caching techniques
  • How to choose the right caching product
  • Custom caching patterns
  • Leveraging caching to share data in Microservices
  • Caching katas (exercises)

Distributed Data Challenges

  • When should you consider distributing data?
  • Single vs. multiple database instances
  • Why distributed data is necessary for microservices
  • Creating data domains
  • Dealing with foreign key constraints
  • Breaking apart the database
  • Dealing with common tables in a distributed architecture
  • Data management and consolidation techniques
  • Distributed transaction management

Service Communication Patterns

  • RESTful communication challenges
  • Messaging communication pattern
  • Leveraging gRPC for service communication
  • API Gateways: The good and the bad
  • Service Orchestration Pattern
  • Service Aggregation Pattern
  • Service Gateway Pattern
  • Understanding the Service Mesh
  • Communication katas (exercises)

Performance Patterns and Techniques

  • Embedded messaging
  • Parallel loader pattern
  • Thread delegate pattern
  • Preserving message order in highly parallel environments

Configuration Patterns for Self-Configuring Systems

  • The problem with application and systems configuration
  • Shift left machine learning algorithm
  • Shift right machine learning algorithm
  • Bracketing machine learning algorithm
  • Applying machine learning algorithms for creating self-configuring systems
  • Configuration broadcast patterns

Application Integration and Integration Hubs (ESBs)

  • Integration styles and protocols
  • Integration hub issues (and resolutions)
  • Processor vs. mediator role
  • Integration hub ownership
  • Integration microservices ecosystems
  • Common integration patterns
  • Integration katas (exercises)

Analysing Software Architecture

  • Macro analysis techniques
  • Micro analysis techniques
  • Code metrics for architecture
  • Architecture analysis tools

Mark Richards

Mark Richards

Mark is an experienced, hands-on software architect involved in the architecture, design, and implementation of Microservices architectures, service-oriented architectures, and distributed systems. He has worked in the software industry since 1983, and has significant experience and expertise in application, integration, and enterprise architecture. He is the author of numerous technical publications and videos, including several books on Microservices, the Software Architecture Fundamentals video series, Enterprise Messaging video series, and is a contributor to 97 Things Every Software Architect Should Know. Mark has a master’s degree in computer science and numerous architect and developer certifications. He is a regular speaker at conferences and user groups around the world, on a variety of enterprise-related technical topics.

Visit website

Follow Mark on Twitter

Click here to register