- Abstraction Distractions
- When Geek Leaks
- 5 Reasons You Should Care about Functional Programming (even if you don’t care about Clojure, Scala, and F#)
Workshops (1/2 or full day)
- Continuous Delivery
- Information Alchemy: Crafting Better Presentations through Patterns
- Introduction to Clojure
60 Minute Sessions
- Agile Architecture & Design
- Rails in the Large: How Agility is Helping Us Build a Huge Rails Application for an Enterprise
- Rampant Emergent Design: Lessons Learned from 4 Years of Agressive Change (coming soon)
90 Minute SessionsA note about timing
The presentations listed below (except for the keynotes, which are minor exceptions to the rule) 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.
- Build Your Own Technology Radar
- The Curious Clojureist
- Emergent Design
- 4 Practical Uses for Domain Specific Languages
- Functional Thinking
- 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.
Why is the relationship between the hippie counter culture of the 1960’s and the existence of spam email? How did a bunch of math geeks almost destroy the financial world? How can you build simpler architectures that scale? How are types of presentations like software designs? This keynote delves into these unexpected relationships and explores what they tell us about the intersection of the real world with software. Software is eating the world, and the geeks who write the code cook the buffet.
(even if you don't care about Clojure and Scala)
In this keynote, Neal explores why learning functional programming paradigms now is critical for developers with five concrete reasons:
- why it’s beneficial to cede control over mundane details to the language and runtime
- how nailgun driven development differs from building prefab houses
- the wonderful benefits of immutability
- embrace results over steps
- how bendable languages make hard problems easier to tackle
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.
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” 3 or 4 times 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.
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.
Domain Specific Languages seem like a cool idea, but where’s the payoff? This talk provides an overview of how to build both internal and external DSLs (including the state of the art tools), stopping along the way to show how this is practical to your day job. This talk defines of DSLs (Domain Specific Languages), distinguishes the types of DSLS (internal and external), and shows examples of building DSLs of several kinds. It shows how to utilize DSLs for externalizing configuration (which you’re already doing, whether you realize it or not), how to make your code readable to humans, how DSLs make developer tools better (and how to use DSL techniques to build your own tools), and how DSLs can provide your users unprecedented flexibility and power, by building DSLs customized to their job. This talk provides a good foundation for the subject if you’ve never seen anything about it, but keeps the focus on practical goals.
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.
- Why should you learn Clojure now? It’s the coolest new language on the JVM
- What makes it so cool? It’s a dynamically typed, functional Lisp that offers sophisticated capabilities like software transactional memory
- Why should I learn it? Lisp is the most powerful style of programming language possible (don’t believe me? Come see - I’ll show you), so you get the best language (Lisp) on the best runtime (JVM)
- Isn’t Lisp the one with all the parenthesis? Yes.
- What’s so compelling about Clojure? It’s fast, expressive, powerful, and allows you to do all sorts of things that other languages won’t let you do. It’s an elegant language.
- Why is the entire talk done as question and answer? It’s an homage to a series of books, The Little Lisper and The Little Schemer. Because Lisp’s are simple and homoiconic, this style works nicely for them. Besides, it’s better than 1000 bullets, isn’t it?
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.
Martin Fowler makes a perceptive observation: the real legacy of Java will be the platform, not the language. More than 200 languages run on the JVM now, and its inevitable that one of them will eventually supplant Java as the best way to program the JVM. Even if that doesn’t happen and Java evolves, it will take on features and characteristics found in next-generation languages on the JVM.
This session explores 3 next-generation JVM languages: Groovy, Scala, and Clojure, comparing and contrasting new capabilities and paradigms. This series will enlighten Java developers with a glimpse into their own near future, providing scaffolding to learn and incorporate new concepts.
While others have been debating whether Rails can scale to enterprise levels, we’ve been demonstrating it. ThoughtWorks is running one of the largest Rails projects in the world, for an “Enterprise”. This session discusses tactics, techniques, best practices, and other things we’ve learned from scaling rails development using agile techniques and tools. We discuss infrastructure, testing, messaging, optimization, performance, and the results of lots of lessons learned, including killer rock-scissors-paper tricks to help get you out of babysitting the view tests!
At ThoughtWorks, we’re big fans of evolutionary architecture and emergent design, which allows great technological and business flexibility. But like many accelerants, it isn’t entirely free. This talk explores decisions made and consequences (both positive and negative) from a real world project that has used these techniques aggressively for 4 years. I discuss the distinction between architecture and design, the impacts of change on each, and how you can sometimes exchange them.
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.
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:
- 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
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.