Online Conference

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.

Nathaniel T. Schutta

Nathaniel T. Schutta is a software architect focused on mobile and making usable applications. A proponent of polyglot programming, Nate has written two books on Ajax and speaks regularly at various worldwide conferences, No Fluff Just Stuff symposia, universities, and Java user groups. In addition to his day job, Nate is an adjunct professor at the University of Minnesota where he teaches students to embrace dynamic languages. In an effort to rid the world of bad presentations, Nate coauthored the book Presentation Patterns with Neal Ford and Matthew McCullough.

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.

Alexander von Zitzewitz

Alexander von Zitzewitz is a serial entrepreneur in the software business and one of the founders of hello2morrow, an ISV specializing in static analysis tools that can enforce architecture and quality rules during development and maintenance of software systems. Alexander has worked in the industry since the early 1980s and focuses on the role of software architecture and technical quality on successful project outcomes. He moved from Germany to Massachusetts in 2008 to develop hello2morrow’s business in North America.

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.

Mark Richards

Mark Richards is an experienced hands-on software architect involved in the architecture, design, and implementation of Microservices Architectures, Service Oriented Architectures, and distributed systems in J2EE and other technologies. He has been involved in the software industry since 1983, and has significant experience and expertise in application, integration, and enterprise architecture. Mark served as the President of the New England Java Users Group from 1999 thru 2003. He is the author of numerous technical books and videos and has a masters degree in computer science and numerous architect and developer certifications from IBM, Sun, The Open Group, and BEA. He is a regular conference speaker at the No Fluff Just Stuff (NFJS) Symposium Series, and has spoken at over 100 conferences and user groups around the world. When he is not working, Mark can usually be found hiking in the White Mountains or along the Appalachian Trail.