Neal Ford
Software Architect, Author, Speaker
Actions
engineering practices.
Neal has a degree in Computer Science from Georgia State University specializing in languages and compilers and a minor in mathematics specializing in statistical analysis. He is an internationally recognized expert on software development and delivery, especially in the intersection of agile engineering techniques and software architecture. Neal authored magazine articles, nine books (and counting), dozens of video presentations, and spoken at hundreds of developers conferences worldwide. His topics include software architecture, continuous delivery, functional programming, cutting edge software innovations, and includes a business-focused book and video in improving technical presentations. His primary consulting focus is the design and construction of large-scale enterprise applications. He is a innovator in building concrete verification mechanisms for software architecture, for humans or agents. If you have an insatiable curiosity about Neal, visit his web site at nealford.com.
Mastering Technical Presentations by Example
Many burgeoning tech leads and architects unhappily discover that, while necessary, technical skills alone do not a successful leader make. It doesn't matter how good your ideas are--if you cannot present them in a compelling way, you'll never get to implement them. The ability to make effective technical presentations is a key soft skill for architects. This session focuses on techniques for building and delivering excellent presentations, using the familiar pattern/anti-pattern format familiar to developers. I present many presentation patterns (and anti-patterns) across a wide range of topics: how to construct slides with the correct amount of information, how to handle detailed technical diagrams effectively, how to build a narrative arc for your presentation, and many others. I also focus on many anti-patterns (such as Bullet-riddled Corpse, a slide filled with bullets) and how to avoid them, covering slide creation, presentation, feedback, questions, and many other topics.
Granularity and Communication in Microservice Architectures
When teams adopt microservices with an understanding the structure of the architecture, but not of how to get all the pieces to communicate, it is all too easy to accidentally create a distributed Big Ball of Mud. Neal introduces a new measure, the architecture quantum, to help analyze and identify communication boundaries and define static and dynamic coupling. Then, the session provides tools--integrators and disintegrators--to help architects iterate towards the correct granularity for their microservices for static coupling. Next, for dynamic coupling, architects must understand when to choose synchronous versus asynchronous communication between services, consistency, and coordination to ultimately analyze transactional sagas; this talk describe eight possible sagas and when each is applicable.
Software Architecture Foundations: Styles, Patterns, and Tradeoffs
Understanding the topology, rationale, and tradeoffs for common architecture styles is a critical foundational skill for architects. Additionally, architects need to know when to use synchronous or asynchronous communication patterns. This online course takes modern engineering practices and perspectives and applies it to a survey of architecture patterns. For each pattern, I discuss the history, philosophy, rationale, topology, optimum uses, and negative tradeoffs. I also discuss common communication patterns within particular styles, along with pros and cons for the architecture style.
Building Evolutionary Architectures Hands-on Workshop
This workshop highlights the ideas from the book Building Evolutionary Architectures, showing how to build architectures that evolve gracefully over time.
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 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 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:
Architecture Dimensions
Engineering Incremental change
Architectural Characteristics
Exercise: determine appropriate characteristics
Identifying Architectural Patterns
Exercise: components and patterns
Identifying Fitness Functions
Exercise: determining fitness functions
Retrofitting Existing Architectures
Building Evolvable Architectures
Building Evolutionary Architectures
An evolutionary architecture supports incremental, guided change along 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 keynote illustrates how to achieve evolutionary architectures and how to retrofit existing systems to support better evolution.
Automating Architecture Governance
A nagging problem for architects is the ability to enforce the governance policies they create. Yet, outside of architecture review boards or code reviews, how can architects be sure that developers utilize their rules? This session describes mechanisms to automate architectural governance at application, integration, and enterprise levels. By focusing on fitness functions, architects define objective tests, metrics, and other criteria to ensure governance polices stick.
Architecture Foundations: Identifying Characteristics
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.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top