Jessitron    Story    Talks    Contact  Blog⇨

(Formerly titled “On the Origins of Opera and the Future of Programming”)

There’s a story to tell, about musicians, artists, philosophers, scientists, and then programmers.

There’s a truth inside it that leads to a new view of work, that sees beauty in the painful complexity that is software development.

Starting from The Journal of the History of Ideas, Jessica traces the concept of an “invisible college” through music and art and science to programming. Along the way she learns what teams are made of, where great developers come from, why changing software is harder for some of us than others, and why this is a fantastic time to be alive.


From Puzzles to Products

Current abstract:

What will help you grow as a developer, skills or understanding? Which internal software has negative business value? When does correctness matter? Oh, and - can software save the world?

Jessica looks to her own career and to the history of Cybernetics for answers – or better, more interesting questions.

Follow her through solving puzzles to growing products and beyond. From Cold War rationality back to Enlightenment reason. Learn new ways to think about your career in software and a new way to talk about your systems.

Original blog

Principles of Collaborative Automation

Great automation doesn’t replace humans; it enhances us. The tools we choose or build for our team need to play like team members: keep us informed, do the consistent boring work, and pass the hard decisions to the humans along with the information we need to make them.

Based on research in human-centered design, this talk enumerates principles and challenges of collaboration for programs. It lists strategies for moving past “human error” and reducing human frustration. Our tools should make us smarter, not hide knowledge from us. In aviation and medicine, this is a million-dollar investment–but when we construct our own tools, collaborative automation is within our reach.


  • 25 January, 2019 at DevOpsDays NYC
  • 12 April, 2019 at DevOps Midwest, St Louis
  • 17 April, 2019 at DevOpsDays, Atlanta

Software Automation in a Polyglot Stack

I spent years as a Java developer, then years gobbling up languages like Scala, F#, Clojure, Elm, and Ruby. Some days I long for the simplicity of one language. How can we have the best of both worlds: flexibility and exploration, without the productivity hit? Jessitron has an answer (hint: it involves even more code).

This talk was implemented in microsessions, grouped in a GitHub org. Find all the materials here: wiki.

Develop Your Development Experience

As developers, we should automate more of our own work.

I’m not happy with this talk, even though I worked really hard on it. Maybe I’ll get it right later. It’s included here for completeness and because hey, nobody gets it right every time.


Forget Velocity, Let's Talk Acceleration

Want to get better at your job? It isn’t enough to keep going. We need to move faster and – even more important – in the right direction. Since the “right” direction is constantly shifting, we need new strategies for acceleration.

As a programmer, we do something new every day. How do we get better at doing new things?

In this session, Jessica has answers both code-based and human-based. Along the way, you’ll find out:

  • Which programming language is the best?
  • What is “done”?
  • and, Why is software development so hard?

Come to this talk if you want to shift how you think about your job, and possibly life.



Shaving the Golden Yak

Programming is a series of frustrations. Everything we do, we could do better or faster if we only had our tools set up just so. If our error messages were a little better, our code a little cleaner, our tests a lot wider. How do you balance the work you’re supposed to be doing with the work that makes your work, work? Dive into the yak stack with me. I’ll get bored with writing code, and write code to write code for me, and then write code to make that easier. Somewhere down here is the golden yak, the one with secret wisdom engraved on its skin.

This session will give you reasons to spend time smoothing your development experience, and clues for where to spend that time in ways that help your whole team.

I wrote the talk up on The Composition


Develop Your Development Automation

Is your work ever boring?

Programming is exciting and challenging when we’re adding features and making the computer do stuff, like serious business work. Programming is boring when we’re getting yet another service up and running and configured in CI. Adding the same methods to matching classes, again. Creating an issue, linking the PR, waiting for the build. Then there are the tasks so tedious we deny their importance and skip them, like upgrading existing services to the latest coding standards and keeping library versions up to date everywhere. What if you could replace every boring task with a few lines of carefully-considered code?

In this session, you’ll see a live demo of how I can automate coordination and code with Rug and Atomist. I can’t get you out of boring meetings, but I can help you stick to the serious business in your coding time.

  • 14 June, 2017 at NDC Oslo
  • 28 April, 2017 at Codemania, NZ

The Architects Below

These days one of the hardest problems in software is software. Code to run our code, code to change our code, code to see into what our code is doing—all determining how our components run and talk to each other. Jessica Kerr explores those powerful architects below that we call infrastructure engineers.



Growing an Elm App

In which Jessitron introduces Atomist:

I love the explicitness and structure of Elm. I don’t love typing.

A mechanical friend can help with both: smart templates modify code to perform common tasks, and Github PRs keep this safe and editor-independent.

See an Elm project created and grown with strategically placed automation.

I love the explicitness and the consistent structure of Elm code and the Elm Architecture. Sometimes I don’t love the typing involved.

Elm is well-suited to code generation. We like to generate code (like with html2elm) and modify it. The automation doesn’t have to end there!

This session will demonstrate growing an Elm app with the help of a smarter templating engine and Github pull requests. Tasks like “add a new component” or “start using elm-test” or “change a service contract” happen safely and mechanically, outside of your favorite editor.

Keep all the structure, skip some of the tedium. See another reason that Elm can be our most productive language system yet.

  • 17 September, 2016 at Elm Conf, St. Louis

Harder and Better

Our job as software developers is harder than it used to be. There’s so much to learn: always new tech, plus now we are supposed to do operations and also understand the business and do our own testing.

Yet, our job is also better - for these same reasons!

This wasn’t recorded and was a unique talk. You had to be there. The Pokemon analogies were great, trust me.


Adventures in Elm

What do you get when you combine strict functional programming with heavy user interaction? Challenges, and unexpected freedoms. Elm is a purely functional language for the browser. It compiles to JavaScript – after enforcing immutability, types, semantic versioning, and tight boundaries for user and server interactions. Working within these restrictions, I find my programming principles turned upside down. Small components? who needs them. Global state? no problem. New principles emerge instead: events, reproducibility, kindness in times of error. This session gives an overview of Elm, then focuses on the Elm Architecture: how it overturns what is essential in object-oriented and even backend functional programming.

  • 11 April, 2016 at Emerging Technologies for the Enterprise, Philadelphia
  • 26 April, 2016 at Craft Conf, Budapest
  • 24 May, 2016 at GOTO Chicago
  • 23 May, 2016 at KCDC, Kansas City
  • 03 November, 2016 at CodeMesh, London

Scaling Intelligence

This opening keynote addressed why learning a language like Scala can be hard, and how we can all make it better.

Scala is a scalable language. It is scalable in the computer sense, of small programs building into large programs. Does it scale in our mind, as well? There are a lot of ideas expressed in Scala. How do we scale those ideas from conception into full use? For any given idea, one person can’t do it alone. There is room in the Scala community for all of us, and a need for all of us. Together, we can scale the language into bigger ideas, into a bigger community, and together realize our own potential and the language’s.



Elixir Should Take Over the World

This keynote compares software innovation to progress in scientific discoveries. Both are the product of many people over time, a product of teaching the people behind us so that they can go farther than we could.

Slides and narration are documented in this PDF.


Video Slides

Functional Principles in React

As software grows, we look for new ways to break it into parts and then hook the parts together. Functional programming is about new ways to isolate and then integrate code. Learn principles behind the trappings of functional programming. React embodies some of these principles — and can embody all of them, if we use it carefully. See how we are untangling the spaghetti of MVC, first with React, then Flux, then Elm. Find out how you’re already following functional principles, and how you can choose to benefit even more.

Slides Code

Contracts and Clojure, the Best-Yet Compromise Between Types and Tests

Clojure makes highly functional programming fun… until it isn’t. Runtime type errors from a function that was returned from another function? I’m longing for Scala’s compiler errors! Nested maps of data make testing easier… until “Wait, what’s in there again?” What I want is a little bit of typing in strategic places: enter Prismatic’s Schema library. What look like types are really contracts. They’re even more powerful than types: they verify values as well as shapes. Exercised in generative tests, these contracts satisfy my type cravings without the pain of satisfying a compiler. There are limitations; schemas can’t express relationships between input and output types… or can they? Schemas don’t express parameterized types… or can they? Explore the potential of contracts as the best-yet compromise between types and tests. No Clojure experience needed.

Slides Code

Complexity is Outside the Code

Everybody does refactoring, right? We keep our code clean and expect that to keep the complexity of our software under control. Except it doesn’t work. If our code is small enough to be simple, and especially if we leverage other libraries and technologies to keep us productive, the complexity shows up in other locations. In a joint keynote with Dan North, I point out that the best we can do is push the complexity outside the code - and suggest how we can deal with it there.


Video Slides Code

Concurrency Options on the JVM

Nobody uses threads and locks directly anymore, thank goodness. Instead, we have a plethora of abstractions. Akka actors, Clojure core.async, Java 8 streams – they’re all beautiful in their different ways. And none of them free us from thinking about threads. This talk focuses on the commonalities between high-level concurrency abstractions, and what you didn’t want to have to know, but should, about the JVM mechanics underneath them.

Video Slides

Property-Based Testing for Better Code (Ruby Version)

What’s better than Test-Driven Development? Even more test driven development - this time with deeper tests. Can we approach mathematical proof without ballooning the lines of test code we maintain? This is the goal of Generative Testing. This kind of test is much harder to write, and that’s the best reason to do it. Thinking before coding is the real purpose of TDD, and generative testing drives us to think harder.

Video Code

Property-Based Testing for Better Code

For reliable services that respond well in changing circumstances, TDD isn’t good enough. Property-based testing, long used in Haskell for testing mathy things, is now a strong tool for testing at the service or module level. With fewer tests, we can think harder, change faster, and know more about our application.

Video Code

Functional Principles for Object-Oriented Development

How is an expert OO developer to improve on their craft? By learning from other paradigms! These six principles of the functional style can apply to OO. Some of these principles are part of good practice already; some express patterns both old and new; all give us different ways of thinking about problems. For developers without expertise in functional programming, examples in Java and C# provide new techniques for writing clear, quality code.

Video Slides Code

When Code Reacts to Data

Data these days: there’s a crapton of it, and a lot of it is crap. We need efficiency, we need resource management, and we need to react to surprises. Can we get just-in-time processing AND secure error handling AND a modular flexibility like OO has never seen? Welcome to a new world of data streaming. You want multiple sources? You want asynchronous, isolated I/O? You want on-the-fly decisions? We have it all! This talk introduces reactive data processing in Scala. See code that modifies its flow at runtime. Scalaz streams (emphasis on the zed) showcases Scala’s confluence of OO+FP with a productively lazy, reassuringly safe, purely functional style. And modularity! I think code re-use is overrated, except like this. In this session, be on the watch for advanced functional programming patterns disguised in ordinary English. You may never think about richly decadent type systems the same way again.

Video Slides Code

Object Oriented Design in the Wild

You’re a great OO developer. Can you use this skill to conquer JavaScript or Haskell or Ruby? There are truths about C# and Java that don’t export, but other principles are universal. Dig into the reasoning behind object-oriented design principles, and find their application in the wider world. Come see how to apply skills you already have to languages you don’t yet know. This session will challenge you to go beyond rules and standards and ask, when is clean code worth your time? Go beyond OO and come back with new insight. You’ll go back to work on Monday with some hard questions to challenge your team.

Slides Code

Functional Principles for Ruby Developers

So you consider yourself an Object Oriented developer? Don’t limit yourself! See what functional programming can do for Ruby. Learn the “why” behind functional programming, and how the same considerations can help OO code. Some of these principles you already use; some express patterns old and new; all give us different ways of thinking about problems. Developers without expertise in functional programming will find new techniques for thinking and coding in Ruby.

Video Slides Code

Git Happens

Git: it’s all the rage in source control. You may use it, but do you understand it? There are a million tutorials out there to tell you what to type, but not why. This talk will show you in pictures what’s going on behind the scenes in git. Those esoteric spells you’ve been typing will make sense, and you’ll know how to untangle your commit history when you get your repo in a knot.

Video Slides

Experience the Tasty Goodness of Guava

Guava is a Java library from Google full of elegant solutions to common problems. From a simple null check to a thread-safe self-populating cache, Guava has something for everyone. This easy-to-include, carefully-designed library gives you true immutable collections, declarative lazy-evaluating list processing, a better event handling pattern – a veritable grab bag of handy Java tricks. Take a quick tour of what Guava offers, with special focus on caching and list processing. Even if Guava is already in your project dependencies, you’ll be surprised at all the juicy goodness inside.