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.

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 (Half, Full, or Two day)

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

90 Minute Sessions

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

Developers are the New Nuclear Physicists [coming soon]

Nuclear physicists used to be considered the most harmless of nerds, until they went and figured out nuclear fission. Many of the Los Alamos mathematicians and scientists were blindsided by the ethical realization that their science project lead to millions of deaths. Currently, developers are considered the most harmless of nerds…

This keynote traces the ethical journey of many fields, including business and science, along with the cultural forces that created their operating perspectives. How did Volkswagon design a software architecture that allowed them to cheat regulators? What drove Facebook to create the ultimate propaganda platform, and what forces resist undoing it? Computer scientists and engineers can no longer naively ignore the ethical and cultural implications of the things they build, and they are gradually awakening to this fact: I point to encouraging signs that, because of shifting cultural zeitgeist, engineers drive companies from the inside to make better choices. This keynote offers a mashup of cultural trends and movements (tracing the journey through modernism, post-modernism, and metamodernism), software architecture, where accounting practices came from, what true 21st century companies will look like, Richard Feynman, and the ethics of software engineering.


Workshops

Software Architecture Fundamentals Workshop [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 Software Architecture Fundamentals Workshop

Part One  [slides]

Part 1 of this workshop focuses on the many elements required to make the journey from developer to architect, covering process topics like the impact of Continuous Delivery on architecture, technical subjects like application, integration, and enterprise architecture, architectural patterns, and soft skills. While we can’t make you an architect overnight, we can start you on the journey with a map and a good compass. Part one covers:

Part Two  [slides]

Part two of this workshop takes a deeper dive in application, integration, and enterprise architecture topics, including translating requirements, comparing service-based architectures, soft skills, architecture refactoring, and more. Part two covers:

Part 3 (hands-on): Architectural Katas [Katas »]

To fully leverage knowledge, you need application. Part three of this workshop my own Katas, based on the public domain Architectural Katas exercise to apply learnings from the first two parts.

From the Architectural Katas website:

Architectural Katas are intended as a small-group (3-5 people) exercise, usually as part of a larger group (4-10 groups are ideal), each of whom is doing a different kata. A Moderator keeps track of time, assigns Katas (or allows this website to choose one randomly), and acts as the facilitator for the exercise.

Each group is given a project (in many ways, an RFP–Request For Proposal) that needs development. The project team meets for a while, discovers requirements that aren’t in the orignal proposal by asking questions of the “customer” (the Moderator), discusses technology options that could work, and sketches out a rough vision of what the solution could look like. Then, after they’ve discussed for a while, the project team must present their solution to the other project teams in the room, and answer challenges (in the form of hard-but-fair questions) from the other project teams. Once that challenge phase is done, the room votes on their results, and the next project team takes the floor.

Part 3, Architectural Katas, is an instructor-led hands-on Katas exercise.


Building Evolutionary Architectures Hands-on  [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 workshop, based on recent 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 different parts of architecture 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 hands-on workshop provides a high-level overview of a different way to think about software architecture.

Outline:

90-minute Sessions

Architecture Foundations: Characteristics & Tradeoffs [slides]

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.


Architecture: The Hard Parts [slides]

Architects often look harried and worried because they have no clean, easy decisions: everything is an awful tradeoff. Architecture has lots of difficult problems, which this talk highlights by investigating what makes architecture so hard. At the of core many architectural problems: getting good granularity, which we illustrate via event-driven architectures, teams, components, architectural quantum, and a host of other examples. We also illustrate reuse at the application, department, and enterprise level, and why reuse seems simple but isn’t. We also discuss difficult decisions, how to do tradeoff analysis, tools like MECE lists, and how to decouple services to achieve proper granularity. Architecture is full of hard parts; by tracing the common reasons and applying lessons more universally, we can make it softer.


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.


Restructuring & Migrating Architectures  [slides]

A common challenge facing many architects today involves restructuring their current architecture or migrating from one architectural style to another. For example, many companies start with monolithic applications for simplicity, but find they must migrate it to another architecture to achieve different architectural characteristics. This session shows patterns/antipatterns, techniques, engineering practices, and other details showing how to make major changes to architectures. This session introduces a new measure, the architectural quantum, as a way of measuring and analyzing coupling and portability within architectures.


Where Do Ideas Come From? Creating, Cultivating, and Communicating IP [slides]

Where do ideas for new talks, books, videos, software…ultimately, everything…come from? A common question at conference panels to the speakers is “Where do you get your ideas for talks?” This session answers that question, along with how some of us cultivate new ideas. This talk investigates three aspects of ideation:

How do new ideas arise?
I cover various ways of synthesizing new ideas: switching axiom(s), mutation, oblique strategies, and a host of other techniques to generate a germ of a new idea

How do ideas grow into intellectual property?
I cover techniques for iterating on ideas to discover deeper meanings and connections. I also cover how techniques to evolve and grow ideas.

How do you communicate new IP?
I cover various ways to convey IP: presentations, articles, books, videos, and a host of other media. I talk about how writing and presenting techniques to amplify your new idea and get it out into the world.

One key to building new IP is separating ideation, organization, and realization, which often become jumbled. By separating them, we can build practices to allow each to flourish. This talk provide concrete advice in each area to help realize new ideas.

Creativity is the reason we have all the Cool Stuff we have. This session investigates how to fan the spark of an idea into a roaring flame of intellectual erudition.




   Follow Neal on Twitter CD image reading image

Neal Ford  |
  • Author, ThoughtWorker, & Meme Wrangler