I’m an avid speaker at software development conferences. Most conferences require talk abstracts to describe the content and thrust of the talk, and it’s often easier to point them to a comprehensive list than send them piecemeal. Thus, 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.
- This is Water is a keynote that describes the water you swim in but cannot see anymore, like relational databases, application servers, and
- Build Your Own Technology Radar describes building two radars, one to help manage your career more effectively and one for your company to help improve decision making, based on the ThoughtWorks Technology Radar metaphor.
- Building Microservice Architectures describes this architectural style, as exemplified by Netflix and Amazon, as the first post-DevOps revolution architecture. This session describes context, what problem are we solving, characteristics of microservice architectures, and engineering practices.
- Continuous Delivery for Architects describes the intersection of Continuous Delivery and architecture, which is surprisingly deep and nuanced. This session describes fleshes out this relationship, providing context, metrics and visualizations, engineering practices, and how to build component and service-based architectures suitable for continuous delivery.
- Functional Thinking in Java 8, Clojure, Groovy, and Scala utilizes its many languages to focus on paradigm over syntax. This session focuses on learning to think like a functional programmer, including higher-order functions, memoization, currying, laziness, and other topics, illustrated using Java 8, Groovy, Scala, and Clojure.
Keynotes differ from “regular” sessions in three important ways. First, they are shorter in duration (50-60 minutes). Second, keynotes are designed to be entertaining to a more diverse audience. Regular sessions tend to deep dive on one topic area, whereas keynotes may cover a wide variety of topics, exposing surprising connections between seemingly disparate subjects. Third, they are more abstract than regular sessions, attempting to invoke Deep Thoughts rather than factual exposition.
Workshops (1/2 or full day)
- Continuous Delivery
- Functional Thinking Hands-on Workshop
- Information Alchemy: Crafting Better Presentations using Patterns
- Software Architecture Fundamentals
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.
- Agile Architecture & Design
- Build Your Own Technology Radar
- Building Microservice Architectures
- Continuous Delivery for Architects
- CryptoCurrency: Implementation and Implications
- Functional Thinking in Java 8, Clojure, Groovy, and Scala
- Information Alchemy: Presentation Patterns & Anti-patterns
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:
- Why does my keyboard look the way it does?
- Why is the iPad is the most revolutionary device in the last 30 years?
- Why do some people hate Maven so much?
- How can I choose technologies with long shelf lives?
- Is hiding always a good thing?
Oh, and some jokes too.
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 odd sounds. Overhead, he sees an airplane flying at 500 mph (without knowing what “airplane”, “flying” or “500 mph” means). Suddenly, one of the creatures picks him up, removes the pain, 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. Additionally, it jerks you out of safe, warm water (briefly) to describe a strange, fantastical world with things like immutable database server, phoenix machines, and lambdas.
You may have trouble getting your friends who didn’t attend to understand.
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.
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 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.
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.
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.
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.
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:
- Plan what you’ll say, who you’ll say it to, how long you’ll talk, and where you’ll present
- Perfectly calibrate your presentation to your audience
- Use the storyteller’s “narrative arc” to full advantage
- Strengthen your credibility—and avoid mistakes that hurt it
- Hone your message before you ever touch presentation software
- Incorporate visuals that support your message instead of hindering it
- Construct slides that really communicate and avoid Ant Fonts, “Floodmarks,” “Alienating Artifacts,” and other errors
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.
Part 1 (knowledge): From Developer to Architect
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, 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 1, From Developer to Architect, covers:
- Soft skills
- Continuous Delivery
- Understanding large codebases
- Architecture patterns
- Architecture anti-patterns
- Integration architecture overview
- Introduction to enterprise architecture
Part 2 (knowledge): Deeper Dive
Part two of this workshop takes a deeper dive in application, integration, and enterprise architecture topics, including evaluating architectures via Agile ATAM, the impacts of continuous delivery on architecture, comparing architectures, SOA, SOAP, and REST, integration hubs, and enterprise architecture approaches and strategies.
Part 2, Deeper Dive, covers:
- Continuous Delivery for architects
- Applying abstraction
- Comparing architectures
- SOAP vs REST/ WS vs Messaging
- Integration hubs
- Enterprise architecture approaches
- Enterprise architecture strategies
Part 3 (application): Architectural Katas
To fully leverage knowledge, you need application. Part three of this workshop uses the public domain Architectural Katas exercise to apply learnings from the first two parts.
From the Architectal 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, Architectal Katas, is an instructor-led hands-on Katas exercise.
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.
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.
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.
Yesterday’s best practice is tomorrow’s anti-pattern. Architecture doesn’t exist in a vacuum, a painful lesson developers who built logically sound but operationally cumbersome architectures learned. Continuous Delivery is a process for automating the production readiness of your application every time a change occurs–to code, infrastructure, or configuration. 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. I first set context for the information you must master before delving into the nuances of modern architectural concerns. 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, the tension between coupling and cohesion, microservices architectures, and other engineering techniques.
Bitcoin has generated a lot of both negative and positive buzz, but it’s important to differentiate between the different aspects of crytocurrency: the algorithm, the commodity, and the implications. This session takes a deep dive on the design and implementation of the proof of work algorithm at the heart of most cryptocurrencies, along with details of how difficult it is to spoof, how transactions work, what happens when all the coins have been mined, and other practical considerations. I also discuss the use of the proof of work algoithm to implement a wide variety of other types of distibuted trust: legal documents, voting systems, and a modification of the entire commerce structure that has existed since medieval times. Don’t be confused by the hype around specific implentations: this algorithm will have wide reaching, tectonic repurcussions.
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 show examples from my book Functional Thinking of shifting your perspective on problems, ceding messy details to the language, working smarter, not harder, and how to deal with multiparadigm languages.
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.