Neal Ford  |
  • Author, ThoughtWorker, & Meme Wrangler

Conference Abstracts

I speak at a large number of software development conferences. Most conferences require talk abstracts to describe the content and thrust of the talk. This is the list of presentations I’m actively submitting to conferences.

These few talks are my most popular offerings, either because of subject matter, timeliness, uniqueness, or some combination of these factors.

Keynotes

Workshops (1/2 or full day)

90 Minute Sessions

A note about timing
The presentations listed below are designed for a particular time interval. Presentations are not fractal! They cannot be arbitrarily shortened or lengthened. I may be able to produce a different timed version, but please ask before you assume.

Keynotes

Abstraction Distractions

Computer science is built on a shaky tower of abstractions, but we’ve been distracted by other things until we believe it is reality. This talk teases apart some of the tangled abstractions that have become so common they are invisible yet impact important decisions. I cover languages, tools, platforms, and burrow all the way down to fundamental concepts. This wide-ranging keynote answers these questions and more:

Oh, and some jokes too.


This is Water

There are these two young fish swimming along and they happen to meet an older fish swimming the other way, who nods at them and says “Morning, boys. How’s the water?” And the two young fish swim on for a bit, and then eventually one of them looks over at the other and goes “What the hell is water?”

David Foster Wallace, from This is Water

A fish is swimming along, having some breakfast, when suddenly he’s snatched out of his world by his food, into a bright world where it’s hard to breathe, landing on the bottom of a boat, where strange alien creatures make strange sounds. Overhead, he sees an airplane flying at 500 mph. Suddenly, one of the creatures picks him up, removes the hook, and, just as suddenly, he’s back home. Yet, when he regales his friends with this tale, no one can believe such a strange world could exist.

This keynote describes the water you swim in but cannot see anymore, like relational databases and application servers. And, it jerks you out of this water (briefly) to describe a strange, fantastical world with things like immutable database servers and phoenix machines. You may have trouble getting your friends who didn’t attend to understand.


Workshops

Clojure (inside out)

Clojure is the most interesting new language on the JVM, both from a syntactic and capabilities standpoint. This workshop teaches attendees Clojure syntax, Java interoperability, and how to build applications, both Swing and Web, using Clojure. After spending time with Clojure, you gradually realize that it isn’t really a new language, but rather a vision for how to write robust applications that could only be realized via a new language—called Clojure. Come see why there is so much buzz around the most innovative new language in a decade.


Continuous Delivery (Full day)

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

Continuous Delivery Workshop Part 1: Deployment Pipelines (90 minutes)

The first part of the workshop describes the technical differences between related topics such as continuous integration, continuous deployment, and continuous delivery. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization’s value stream for delivering software. I discuss the various stages, how triggering works, patterns and anti-patterns, and how to pragmatically determine what “production ready” means. This session also covers some agile principles espoused by the Continuous Delivery book, including new perspectives on things like developer workstations and configuration management.

Continuous Delivery Workshop Part 2: Testing, Synergistic Practices, and Deployment (90 minutes)

Continuous Delivery relies on a variety of interlocking engineering practices to work efficiently; this session covers three related topics. First, I cover the role of testing and the testing quadrant, including the audience and engineering practices around different types of tests. I also cover some best practices around testing, including testing ratios, code coverage, and other topics. Second, I specifically cover version control usage and offer alternatives to feature branching like toggle and branch by abstraction. Generally, I talk about building synergistic engineering practices that complement rather than conflict one another. In particular, I discuss why feature branching harms three other engineering practices and describe alternatives. Third, I describe some incremental release strategies, along with their impact on other stages of project lifecycle.

Continuous Delivery Workshop Part 3: Infrastructure and Data (90 minutes)

Two big stumbling blocks for Continuous Delivery adaptation are interactions with operations and the keepers of data. First in this session, I cover operations, DevOps, and programmatic control of infrastructure using tools like Puppet and Chef. I also discuss the explosion of tool alternatives in this space, and cover some current-day best practices. Second, I discuss how to incorporate databases and DBA’s into the Continuous Integration and Continuous Delivery process. This includes database migrations, strategies for enhancing collaboration between application development and data, and database refactoring techniques.

Continuous Delivery Workshop Part 4: Continuous Delivery for Architects

Note: this is the same as the stand-alone Continuous Delivery for Architects session Continuous Delivery is a process for automating the production readiness of your application every time a change occurs—to code, infrastructure, or configuration. It turns out that some architectures and practices yield code that works better in this environment. This session takes a deep dive into the intersection of the architect role and the engineering practices in Continuous Delivery. In the Continuous Delivery world, rather than hone skills at predicting the future via Big Design Up Front, the emphasis lies with techniques for understand and changing code with less cost during the process. I discuss the role of metrics to understand code, how Domain Driven Design’s Bounded Context reifies in architecture, how to reduce intra-component/service coupling, and microservices architectures, and other engineering techniques.


Evolutionary Architecture and Emergent Design Hands-on Workshop

Coming in 2015!

Donald Rumsfeld was right: it’s the unknown unknowns that are the real killers in software development. Design decisions made too early are just speculations without facts. But you must have architecture in place before you can do anything. This session talks about the tension between architecture & design in agile projects, discussing two key elements of emergent design (utilizing the last responsible moment and harvesting idiomatic patterns) and how to de-brittlize your architecture, so that you can play nicely with others. This workshop shows techniques and tools and then allows you to apply them to either a sample or (for the very brave) your own code base during the hands-on exercises.


Functional Thinking Hands-on Workshop

Coming in 2015!

Learning the syntax of a new language is easy, but learning to think under a different paradigm is hard. And while looking at code is nice, building it is even nicer. In this two-part workshop, I show how to stop thinking imperatively and start thinking functionally through s series of hands-on exercises in the language of your choice (even old-school Java – I have frameworks). Learn how to replace iteration with higher-order functions, caching with memoization, workflows with streams, and building concurrent solutions without losing your mind.


Information Alchemy: Crafting Better Presentations through Patterns

Patterns are like the lower-level steps found inside recipes; they are the techniques you must master to be considered a master chef or master presenter. You can use the patterns in this session to construct your own recipes for different contexts, such as business meetings, technical demonstrations, scientific expositions and keynotes, just to name a few. Although there are no such things as anti-recipes, this session shows you lots of anti-patterns, things you should avoid doing in presentations. Modern presentation tools often encourage ineffective presentation techniques, but this session shows you how to avoid them. Each pattern is introduced with a memorable name, a definition, and a brief explanation of motivation. Attendees learn where the pattern applies, the consequences of applying it, and how to apply it. The authors also identify critical anti-patterns: clichés, fallacies, and design mistakes that cause presentations to disappoint. These problems are easy to avoid – once you know how.

Presentation Patterns will help you:

90-minute Sessions

Agile Architecture & Design

Donald Rumsfeld was right: it’s the unknown unknowns that are the real killers in software development. Design decisions made too early are just speculations without facts. But you must have architecture in place before you can do anything. This session talks about the tension between architecture & design in agile projects, discussing two key elements of emergent design (utilizing the last responsible moment and harvesting idiomatic patterns) and how to de-brittlize your architecture, so that you can play nicely with others. This talk includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping your code in sync with the problem domain.


Build Your Own Technology Radar

ThoughtWorks’ Technical Advisory Board creates a “technology radar” twice a year, a working document that helps the company make decisions about what technologies are interesting and where we will spend our time. This is a useful exercise both for you and your company. This session describes the radar visualization, how to create litmus tests for technologies, and the process of building a radar. You need two radars. As an individual, a technology radar helps guide your career decisions and focus your precious R&D time. For your company, creating a radar helps you document your technology decisions in a standard format, evaluate technology decisions in an actionable way, and create cross-silo discussions about suitable technology choices. Attendees will leave with tools that enhance your filtering mechanisms for new technology and help you (and your organization) develop a cogent strategy to make good choices.


Building Microservice Architectures

Inspired by success stories from companies such as Amazon and Netflix, many organizations are moving towards microservice architectures at a brisk pace. This style of architecture is important because it’s the first architecture to fully embrace the Continuous Delivery and DevOps revolutions. In this session, I cover the motivations for building a microservice architecture (including making the distinction between “regular SOA” and microservices), some considerations you must make before starting (such as transactions versus eventual consistency), how to determine service partition boundaries, and ten tips to dowse you towards success. I also discuss the role of polyglot development, enterprise governance, how data and databases fit into this new world, and tooling to help ensure consistency between core services like logging and monitoring. This session provides a thorough overview of the pros and cons for microservice architectures, when it is applicable, and some nascent best practices.


Communication Skills for Knowledge Workers

Coming in 2015!

Who’s job never disappears to another country? The person who can explain how and why things work. Communication is as fundamental to software development as source code, yet many knowledge workers can’t convey their ideas succinctly and concisely. This session describes communication techniques and skills to people who skipped English 102 to hack some code. I discuss multiple aspects of communication in the workplace:


Continuous Delivery for Architects

Continuous Delivery is a process for automating the production readiness of your application every time a change occurs–to code, infrastructure, or configuration. It turns out that some architectures and practices yield code that works better in this environment. This session takes a deep dive into the intersection of the architect role and the engineering practices in Continuous Delivery. In the Continuous Delivery world, rather than hone skills at predicting the future via Big Design Up Front, the emphasis lies with techniques for understand and changing code with less cost during the process. I discuss the role of metrics to understand code, how Domain Driven Design’s Bounded Context reifies in architecture, how to reduce intra-component/service coupling, and microservices architectures, and other engineering techniques.


The Curious Clojureist

Clojure is the most interesting new language on the horizon, but many developers suffer from the Blub Paradox when they see the Lisp syntax. This talk introduces Clojure to developers who haven’t been exposed to it yet, focusing on the things that truly set it apart from other languages. I discuss all of Clojure’s syntax (in about 10 minutes), then delve into fascinating features like destructuring, building macros like thread-first and thread-last, the Atomic Succession Model of Concurrency, Clojure’s use of Protocols to organize code and solve The Expression Problem, and many more cool features. Come see why some of our most sophisticated projects are using Clojure.


Emergent Design

This session describes the current thinking about emergent design, discovering design in code. The hazard of Big Design Up Front in software is that you don’t yet know what you don’t know, and design decisions made too early are just speculations without facts. Emergent design techniques allow you to wait until the last responsible moment to make design decisions. This talk covers four areas: emergent design enablers, battling things that make emergent design hard, finding idiomatic patterns, and how to leverage the patterns you find. It includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping your code in sync with the problem domain.


Functional Thinking

Learning the syntax of a new language is easy, but learning to think under a different paradigm is hard. This session helps you transition from a Java writing imperative programmer to a functional programmer, using Java, Clojure and Scala for examples. This session takes common topics from imperative languages and looks at alternative ways of solving those problems in functional languages. As a Java developer, you know how to achieve code-reuse via mechanisms like inheritance and polymorphism. Code reuse is possible in functional languages as well, using high-order functions, composition, and multi-methods. I take a variety of common practices in OOP languages and show the corresponding mechanisms in functional languages. Expect your mind to be bent, but you’ll leave with a much better understanding of both the syntax and semantics of functional languages.


Information Alchemy: Presentation Patterns (& Anti-patterns)

Creating and delivering technical presentations is not just the realm of conference speakers anymore. Let’s face it: if you have to give a technical presentation and it’s boring, you’re not going to make much of an impact. However, if you can make it entertaining and informative, you sell your ideas much better. This session takes a different approach to how to build presentations, by providing patterns and anti-patterns you can use to make sure you’re getting the most leverage from your presentations. Don’t take a knife to a gunfight! The ability to create compelling presentations that explain your point is one of the things that keeps your job from disappearing.




   Follow Neal on Twitter

Neal Ford  |
  • Author, ThoughtWorker, & Meme Wrangler