Michael Nygard

Presentations

Architect for Scale

Is your system small, medium, large, or super-size? Is traffic on it's way up?

Architecture patterns and structures that work at one scale seldom work across all of them. A communication style that's appropriate for small websites will probably fail badly if you apply it to world-wide networks of computers. Likewise, structures that work for large-scale systems are probably too complex and expensive to be worth it for small sites.

In this talk, Michael will discuss the notion of "design envelopes" for architectures. He will explore several common scaling strategies and map them to different system scales.

During this session, Michael will present reference architectures for systems at a variety of scales. It's sometimes possible to scale smoothly from range to range, but it can be extremely disruptive if you don't plan for it.

Along the way, he'll also address the different dimensions of scalability problems: traffic, content, data volume, and operations.

High Performance Persistence with Redis

Redis is one of the fresh crop of "NoSQL" storage solutions. It's a distributed key-value store that knows how to deal with data structures. Oh, and it happens to also be incredibly fast. Like, microseconds per write.

This session shows how to get Redis set up in standalone and replicated mode and how to start using it for persistence. It will also show some techniques to structure your data to achieve consistency without transactions.

When the Fur Flies: Dev and Ops Cooperation when the Worst Happens

There's nothing like a crisis to remove artificial barriers. In this session, Michael will present an experience report about development and operations coming together after a failed launch.

Aside from the fun of sharing war stories and comparing scars, what can we learn about climbing out of a crater after the worst has already happened? Can we capture the special magic of a firefighting mission during more sedate times?

Design for Operations

If your software fails in production, nobody will care how great the development project was, or how well the system passed QA. Production operations, the domain of your systems' least-appreciated stakeholders, is where the rubber meets the road. Come learn how to build your systems to thrive in Operations.

We will explore the most critical foundations for success in Operations: transparency, control, deployments, and configuration.

Along the way, we'll see some of the organizational dysfunction that prevents smooth, successful operations. You'll learn what you can do today to avoid these dysfunctions, even if you've inherited a legacy of distrust between Development and Operations.

If you don't want to wear a pager for the rest of your life, this session is for you.

DSLs in Scala: Internal and External

We're no longer working in a single language. Programming today is about both consuming and creating languages.

We've all heard a lot about domain specific languages (DSLs). So much so, in fact, that it seems like more people are talking about it than doing it. In this session, Michael will present a real domain with familiar problems. He'll then demonstrate both an internal DSL and an external DSL that solve the same problem. Along the way, we'll cover fluent interfaces, composing multiple DSLs, and the very cool parser combinators.

If you've ever left a DSL talk wondering when we're ever going to get past the "coffee ordering DSL" or the "Waffle House breakfast DSL", then you will want to see this session.

This session walks through the creation of a domain model with an internal DSL based on a fluent interface in Scala. Although this is not an introduction to Scala, the necessary Scala concepts will be covered sufficiently for anyone to follow.

After demonstrating the domain and the internal DSL, Michael will use parser combinators to build a grammar in just a few lines of code. This grammar will lex and parse the input files, along with constructing domain objects for further use.

Stability Antipatterns

In this workshop, you will learn how to create applications that survive the rigors of life in production. Too often, project teams aim to pass QA instead of aiming for success in production. Testing is not enough to prove that your software is ready for continuous availability in the corrosive environment of the Internet.

During this course, you will receive an understanding of the architecture and design patterns that can produce high availability in distributed, multithreaded systems such as those based on Java EE, .Net, or Ruby on Rails. You will also learn about the antipatterns that can sabotage your systems availability and capacity.