Essentials of Software Architecture
Presented by: Nathaniel T. Schutta, Alexander von Zitzewitz, and Mark Richards
July 12, 2016
10:00AM – 1:00PM PT
Sign up before this conference sells out!
Software architecture is a huge, multidisciplinary subject covering many roles and responsibilities. Where do you begin? In this online conference, three experienced software architects will address essential topics: modeling, handling dependencies and architectural debt, and design patterns. You’ll learn about tradeoffs, technology options, and engineering practices that can be critical to the long-term success of your projects and organization. At the conclusion of this conference, you’ll be able to view your everyday challenges with an architect’s eye, armed with practical approaches and tested techniques that you can apply to your work immediately.
Session 1: 10:00AM
Modeling for software architects
In some organizations, architects are dismissed as people who draw box-and-arrow diagrams (the dreaded whiteboard architect). While we don’t want to foster that stereotype, it’s important for an architect to be able to construct basic architectural diagrams. An architect must also be able to separate the wheat from the chaff so to speak, eliminating those models that don’t help tell the story. In this session, Nathaniel will walk you through a set of diagrams that effectively communicate as he discusses the true value of creating an architectural model.
Session 2: 11:00AM
Love your architecture
Most non-trivial software systems suffer from significant levels of technical and architectural debt. This leads to exponentially increasing cost of change, which is not sustainable for a longer period of time. The single best thing you can do to counter this problem is to give some love to your architecture by carefully managing and controlling the dependencies between the different elements and components of a software system. Alexander von Zitzewitz first shows you why so many systems end up in an unmaintainable state. Then you’ll see show how to address the problem using automated quality gates with a focus on architectural and metric-based rules.
Session 3: 12:00PM
Software architecture patterns
Just as developers use design patterns in software development, architects use well-defined architecture patterns to define the characteristics and shape of the architecture. Using the wrong architecture pattern (or no pattern at all) can sometimes be a very costly mistake resulting in an architecture that doesn’t work. It is therefore vital that architects are aware of and understand the various architecture patterns available. In this session, Mark Richards will discuss several common architecture patterns, including microservices architecture, event-driven architecture, layered architecture, microkernel architecture, and space-based architecture. For each pattern, he’ll discuss the basic topology, major architecture components, and driving characteristics. You’ll see how requirements and operational aspects can drive which patterns to use.