Neal Ford  |
  • Author, Thoughtworker, & Meme Wrangler

Conference Presentation Abstracts (and Slides)

I’m an avid speaker at business and software development conferences. Most conferences require talk abstracts to describe the content and thrust of the talk, and it’s often easier to point the organizers to a comprehensive list than send abstracts piecemeal. This therefore is the list of presentations I submit to conferences for my current topics.

A note about the slides: I’m a firm believer (in fact, wrote a book about) using slides as a support mechanism, not the entire story–the presenter is the other half. Therefore, if you want to download the slides, feel free…however, be forewarned that they probably won’t make any sense with me standing in front of them talking, as you can only see half the story.

Keynotes

Keynotes differ from “regular” sessions in three important ways. First, they are shorter in duration (50-60 minutes). Second, I design keynotes to entertain a more diverse audience. Regular sessions tend to deep dive into one topic area, whereas keynotes may cover a wider variety of topics, exposing surprising connections between seemingly disparate subjects. Third, they are more abstract than regular sessions, encouraging Deep Thoughts in addition to pure factual exposition.

Workshops are multi-segment courses with deeper content and hands-on exercises.

A note about timing
I designed the presentations listed below for a particular duration. Presentations are not fractal: I cannot arbitrarily shortened or lengthened them. I may be able to produce a different duration version, but please ask before assuming.

Keynotes

Meta-modern Software Architecture 

Where do architecture styles come from? Do architects retreat to an ivory tower to decide what the Next Big Thing will be? No–new capabilities constantly appear in the software development ecosystem, and clever architects figure out new ways to leverage the new building blocks, leading to new named architecture styles which are only named after they have existed for a while. This is similar to art and cultural movements, how Victorianism became Modernism. In this keynote, Neal traces the similarities between architecture styles and cultural movements, how each affects the other, and points towards how Metamodernism will inform architecture, corporations, and individual workers in a fundamental way.

Software Architecture: The Hard Parts  [slides available soon]

“Software architecture” is the stuff you can’t Google. Developers become adept at searching for solutions to the technical issues they face–but what about architects? Their solutions are generic; rather, each decisions features significant trade-offs. This keynote, based on the eponymous book, delves into many of the areas in software architecture where difficult decisions lie and discusses techniques for evaluating those trade-offs to reach informed decisions. The job of an architect isn’t to find silver- bullet solutions to problems (they are too rare); instead, architects should hone their ability to perform objective trade-off analysis for novel situations (because all situations in architecture are novel). This keynote unlocks many techniques that architects can use to make better decisions.

Workshops

Fundamentals of Software Architecture Hands-on [1 Day] [2 Day]

The job Software Architect places in the top ten of most annual surveys of best jobs, yet no clear path exists from Developer to Architect. Why aren’t there more books and training materials to fill this demand? First, software architecture is a massive multidisciplinary subject, covering many roles and responsibilities, making it difficult to teach because so much context is required for the interesting subjects. Second, it’s a fast moving discipline, where entire suites of best practices become obsolete overnight. This workshop provides a foundation to build upon to start the journey towards software architect. I offer three different versions of this workshop based on length.

One-day Workshop

This workshop focuses on the foundational material required for success as a modern software architecture. It touches upon the major design elements of the role and discusses several soft skills such as communication as well.

Building Evolutionary Architectures Hands-on  [slides]

An evolutionary architecture supports incremental, guided change across multiple dimensions.

This workshop highlights the ideas from the book Building Evolutionary Architectures 2nd Edition, showing how to build architectures that evolve gracefully over time. For many years, software architecture was described as the “parts that are hard to change later”. But then microservices showed that if architects build evolvability into the architecture, change becomes easier. This workshop covers two important aspects of how to make software architecture evolvable: mechanics and structure. Mechanics describes the concept of an architectural fitness function, allowing architects to build evolvability into their systems and automate governance (which go hand in hand). The second part focuses on architectural structure and coupling, and each impacts an architects ability to facilitate change in architecture. Last, the workshop combines mechanics and structure to describe how each work hand in hand with each other.

This workshop includes hands-on, team based exercises to illustrate concepts and make them concrete.

Outline:

Software Architecture: The Hard Parts Workshop (2-days)   [Coming Soon]

Software architecture” is the stuff you can’t Google. Developers become adept at searching for solutions to the technical issues they face–but what about architects? Their solutions are generic; rather, each decisions features significant trade-offs. This workshop, based on the eponymous book, delves into many of the areas in software architecture where difficult decisions lie and discusses techniques for evaluating those trade-offs to reach informed decisions. The job of an architect isn’t to find silver- bullet solutions to problems (they are too rare); instead, architects should hone their ability to perform objective trade-off analysis for novel situations (because all situations in architecture are novel). This workshop unlocks many techniques that architects can use to make better decisions.

Agenda:

Part 1: Pulling Things Apart

1) What Happens when there are no “Best Practices”?

2) Discerning Coupling in microservices

3) Component Decomposition Patterns

4) Pulling Apart Operational Data

5) Service Granularity

Part 2: Putting Things Back Together

6) Data Ownership & Eventual Consistency

7) Distributed Data Access

8) Coordination: Managing Distributed Workflows

9) Transactional Sagas

10) Contracts

11) Data Mesh

60-90 minute Sessions

Architecture Foundations: Characteristics & Tradeoffs ]

Architects must translate domain requirements, external constraints, speculative popularity, and a host of other factors to determine the key characteristics of a software system: performance, scale, elasticity, and so on. Yet architects must also analyze the tradeoffs each characteristics entails, arriving at a design that manages to maximize as many beneficial properties as possible. This session describes how architects can identify architectural characteristics from a variety of sources, how to distinguish architectural characteristics from domain requirements, and how to build protection mechanisms around key characteristics. This session also describe a variety of tradeoff analysis techniques for architects, to try to best balance all the competing concerns on software projects.

Architecture Foundations: Styles & Patterns [slides]

A key building block for burgeoning software architects is understanding and applying software architecture styles and patterns. This session covers basic application and distributed architectural styles, analyzed along several dimensions (type of partitioning, families of architectural characteristics, and so on). It also provides attendees with understanding and criteria to judge the applicability of a problem domain to an architectural style.

Understanding Modern Trade-off Analysis in Software Architecture 

There are no best design practices in Software architecture–everything is a trade-off. But how do you figure out what those are? The answer to every question in software architecture is “It depends.” This keynote starts to answer the follow up question: “Depends on what?!?” It proves a variety of techniques and tools to help architects and other teams members understand and evaluate trade-offs, including how to perform iterative design and how to avoid common trade-off traps.

Building Evolutionary Architectures [slides]

An evolutionary architecture supports incremental, guided change across multiple dimensions.

For many years, software architecture was described as the “parts that are hard to change later”. But then microservices showed that if architects build evolvability into the architecture, change becomes easier. This talk, based on my upcoming book, investigates the family of software architectures that support evolutionary change, along with how to build evolvable systems. Understanding how to evolve architecture requires understanding how architectural dimensions interact; I describe how to achieve appropriate coupling between components and services. Incremental change is critical for the mechanics of evolution; I cover how to build engineering and DevOps practices to support continuous change. Uncontrolled evolution leads to undesirable side effects; I cover how fitness functions build protective, testable scaffolding around critical parts to guide the architecture as it evolves.

The software development ecosystem exists in a state of dynamic equilibrium, where any new tool, framework, or technique leads to disruption and the establishment of a new equilibrium. Predictability is impossible when the foundation architects plan against changes constantly in unexpected ways. Instead, prefer evolvability over predictability. This talk illustrates how to achieve evolutionary architectures and how to retrofit existing systems to support better evolution.

Granularity & Communication for Microservice Architectures [coming soon!]

Architects struggle in modern distributed architectures with two Hard Parts: finding the appropriate service granularity and determining the correct communication styles between services. This talk introduces a new technique for performing tradeoff analysis for microservices architectures around both static and dynamic coupling. Static coupling helps determine the proper granularity by applying integrators and disintegrators. Dynamic coupling helps architects understand the interplay between communication (synchronous versus asynchronous), consistency (atomic versus eventual), and coordination (orchestration versus choreography), along with guidelines on when to choose particular communication styles. In this talk, Neal provides architects with the nomenclature and patterns to understand these difficult aspects of microservices and related architectures.

Software Architecture by Example  [coming soon...]

While many attendees learn from abstract concepts, others prefer to see concepts in action. This session eschews software architecture theory and instead illustrates the process of architecture design using two concrete examples: Silicon Sandwiches and Going, Going, Gone. For each of these problems, Neal shows how:

Each step of the way, the two example problems illuminate the stages of architecture design and the considerations architects must make at each stage.



   Follow Neal on Twitter music image opera image reading image

Neal Ford  |
  • Author, Thoughtworker, & Meme Wrangler