Docker Means Less Developer Downtime

Less time waiting to launch VM's

• Launching a container is usually very, very fast, usually less than 5 seconds.
• Order of magnitude difference compared to VM's.

Less Time Setting Up Dev Environments

• Reproducing prod is much easier when it and your laptop are using the same Docker images.

Docker Means More Consistent Delivery Quality

The App Server Paradigm Shift

Coupling Your App Server And Code

• Your code and app server are "squished together" and that's your deployable.
• I repeat, you don't deploy code, you deploy single-purpose servers.

We're Not Building Cathedrals Any More

You Forgot To Say Immutable!

• Not quite, depends on how you use them
• Not true immutability, but better than what we have today.
• Old containers are not patched, they are replaced

It Works On My Machine

• We're now almost to the point where you can say this :-)
• The containers that run on your machine are the same ones that run in Prod.

The Way Things Are

Middleware Priesthoods

• In a lot of large shops, the middleware groups control everything between the deployable and OS.
• App and web server software
• Database
• OS
• This "priesthood" adds a very large layer of coordination and costs.

Modern IT Org Structure

The Delivery Chasm

Rigid Architecture

• Setup is very slow and costly
• You can't try new things out

Middleware Dictates Architecture

• Perfectly good software choices are denied due to organizational issues, not technical ones.
• If software is stable and secure, then shouldn't the developers be able to use it?

Middleware Dictates Project Schedules

• Middleware teams tell Dev teams when they can upgrade.
• Upgrades are often forced on project teams and can cause significant
delays.

What is the cost benefit?

There are certainly cost benefits of the current model, but these sorts of issues really make you question them.

The Way Things Could Be

Delivering Code + Runtime

• Developers now have a standardized way of specifying a language, runtime, and supporting libs using Docker.
• Middleware teams will no longer have a good reason to force a single toolset on developers.

Faster Delivery

More Agility

• Systems can be spun up and destroyed very easily
• Costs and complexity of trying new ideas is reduced significantly
• Experimentation becomes cheap, easy and business-as-usual

The Results - Shrinking Middleware