Neal Ford  |
  • Author, ThoughtWorker, & Meme Wrangler

Conference Abstracts

Keynotes

Workshops (1/2 or full day)

3/4 Day (4.5 hour) Continuous Delivery Workshop

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

This is Water

Meta-abstract

This keynote starts with this video adaptation of David Foster Wallace’s commencement address entitled This is Water. It then takes one of the themes of the video (that people tend not to notice the really important things in life) and apply it to software projects and current “best practices”.

Abstract

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, abruptly ejected 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.


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.


8 Reasons You Should Care about Functional Programming

(even if you don't care about Clojure, Scala, and F#)

In this keynote, Neal explores why learning functional programming paradigms now is critical for developers with eight concrete reasons:

Even if you don’t care about Scala, Clojure, F#, or Haskell, the important features of those languages will impact your life. Now is the time to increase your comfort level with these new paradigms.

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 or half day)

Getting software released to 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.

Part 1: Deployment Pipelines (90-180 minutes)

In this workshop I move from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. 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 spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.

Part 2: Agile Infrastructure (90-180 minutes)

In the second half of the workshop, I introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.


3/4 Day Continuous Delivery Workshop

Getting software released to 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 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, and describes the new technical artifact that Continuous Delivery introduces, the deployment pipeline. I discuss the various stages, how triggering works, and how to pragmatically determine what “production ready” means.

Continuous Delivery Workshop Part 2: Testing & Holistic Engineering Practices (90 minutes)

In part 2 of the Continuous Delivery workshop, I cover the role of testing, including the audience and engineering practices around different types of tests. I also discuss integrating manual testing into the Continuous Delivery process, along with testing best practices to improve the return on effort required to create tests.

I also cover tools such as continuous integration servers and version control and how to hone your engineering practices to avoid inefficiency. In particular, I discuss why feature branching harms other engineering practices and describe alternatives.

Continuous Delivery Workshop Part 3: Infrastructure, Environments, & Data (90 minutes)

In part 3 of the Continuous Delivery workshop, I cover DevOps and related practices, programmatic control of infrastructure using tools like Puppet and Chef, how to incorporate databases and DBA’s into the Continuous Integration and Continuous Delivery process. I also cover some tips on how to roll out Continuous Delivery in organizations of all sizes, how to get started, and some key metrics to track to evaluate progress.


Evolutionary Architecture and Emergent Design Hands-on Workshop

Coming in 2014!

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 2014!

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 antirecipes, this session shows you lots of antipatterns, 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 antipatterns: 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.


Communication Skills for Knowledge Workers

Coming in 2014!

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