Jessitron   Talks   Contact  Blog⇨

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.

Video
  • 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.

Video
  • 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.

Video

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.