Chris Keathley on Performance and Functional Programming

Our guest on the show today is blogger, software cowboy, and podcast host Chris Keathley. Chris is a senior engineer at Bleacher Report, co-host of Elixir Outlaws, and writer of an assemblage of open-source software. He joins us today to speak about his new projects, his journey with functional programming, and what it is like to run Bleacher Report’s infrastructure on Elixir. Chris gives us the lowdown on Norm, a data validating interface he recently completed, weighing in on how it is different from Dialyzer and what it can offer as far as scalability. We hear more about how Chris got introduced to Elixir through Haskell, why he wishes he learned Clojure sooner, and why Ruby on Rails isn’t going anywhere soon.

Chris also gets into the tradeoffs these languages make to correlate with Erlang. He argues that Elixir can only be more widely adopted if more people build cool things in it, and then lays out some of its power in supporting Bleacher Report’s user interface. We pick Chris’s brain about what his company is trying to optimize at the moment and hear about their preference for capacity over speed, and their techniques for failing gracefully during traffic spikes. Chris tells us how much he loves Elixir due to its use of ETS and other functionality which allows Bleacher Report to keep running even above capacity. Finally, we hear about some of the observability practices that Bleacher Report uses when deploying new systems and predicting future spikes. Plug in for a great conversation and hear why you should get building with Elixir now!

Key Points From This Episode:

• Chris’s explanation of Norm, his new software that describes data moving through a system.
• Chris’s introduction to functional programming through learning Haskell, Clojure, and Elixir.
• What makes a great functional language: immutable data and first class functions.
• Things that make Clojure great, such as its thought out, holistic design.
• Characteristics of Cons lists versus RRB trees, and what makes the latter better.
• An acknowledgment of the necessity of the tradeoffs Elixir makes to interact with Erlang.
• A little bit about the language Chris wrote to do the admin of code challenges in.
• Why Ruby (on Rails) will not be replaced by Elixir due to commoditization that surrounds it.
• An argument that Elixir can only be more widely adopted if more people build with it.
• Why any language can build any program thus comparisons between them are arbitrary.
• Where Chris sets the bar as to when something is performant.
• Chris’s preference for high user capacity capability over speed of delivery at Bleacher Report.
• Optimization projects at Bleacher Report such as using few boxes and handling traffic spikes.
• Things Chris loves about Elixir such as its ability to deliver more from its boxes.
• Elixir’s use of ETS and how Chris coded a complex problem in half a day using it.
• How Chris detects spikes using time series, StatsD, and other observability tools.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Chris Keathley on GitHub — https://github.com/keathley
Chris Keathley Blog — https://keathley.io/
ElixirConf 2019, Contracts for Building Reliable Systems presented by Chris Keathley — https://www.youtube.com/watch?v=tpo3JUyVIjQ
The Big Elixir 2019 - Keynote: Adoption - Brian Cardarella — https://www.youtube.com/watch?v=ghpIiQKRfQ4
Bleacher Report — https://bleacherreport.com/
Elixir Outlaws Podcast — https://elixiroutlaws.com/
Norm — https://github.com/keathley/norm
Dialyzer — http://erlang.org/doc/man/dialyzer.html
Haskell — https://www.haskell.org/
Clojure — https://clojure.org/
Erlang — https://www.erlang.org/
Chris Okasaki — https://github.com/chrisokasaki
Discord — https://discordapp.com/company
StatsD — https://www.datadoghq.com/blog/statsd/
Prometheus — https://prometheus.io/
Opentracing — https://opentracing.io/

Special Guest: Chris Keathley.