Empex 2017 Meetup Recap

Another Empex is behind us, and here is a small recap of the one-day soul filled NYC conference (last year’s recap for 2016 is found here). Lots of great talks, I will just highlight a few (mostly because there were no “plugs”, so I limited my note-taking).

Travis Vander Hoop gave a talk Channels as Controllers (An Exercise in Refactoring) on refactoring Phoenix Channels in an effort to help avoid a coding culture of adding just one more feature directly within the channel.

  1. Use join/3 to include initial state when a user joins
  2. Move CRUD operations into the Controller
  3. Focus Channels on join and message passing, little else
  4. Consider (wearily) macros to further reduce boilerplate code

He used remote_retro to demonstrate the refactor, an app which in itself is a neat use of Phoenix (as a means to conduct remote agile retrospectives).


In When Does Concurrency Pay Off? from Will Carrol, we explored the depths of concurrency performance and Amdahl’s Law which is

mainly used to predict the theoretical maximum speedup for program processing using multiple processors.

In other words, the limitation on performance boils down to how much serialization you do (in proportion to what’s done in parallel) as a means to calculate the maximum how much faster you could make the system if you added more cores.

We explored :timer.tc to quickly measure the execution of your code, and the use of Task.async as an easy way to parallelize, and Flow as a more sophisticated approach. For example:

File.stream!("path/to/some/file")
|> Flow.from_enumerable()
|> Flow.flat_map(&String.split(&1, " "))
|> Flow.partition()
|> Flow.reduce(fn -> %{} end, fn word, acc ->
Map.update(acc, word, 1, & &1 + 1)
end)
|> Enum.to_list()

Saša Jurić gave his talk on Solid Ground. You can check out the slides, or watch a video from Elixir Daze.


The final Keynote from talk from Jessica Kerr on “The Language Is the Least Of It” was jam packed with insight, although a little scatterbrained in my opionion. The main points of discussion included

  • Progress is best made through small feedback looks, which in the Elixir space is a revolving circle of goodies including iex, elixir script .exs, automated tests, builds, helper scripts, automated deployment and pipeline.
  • Micro automations (aka just for you and your team) can make huge efficiency gains.
  • Software development is always new. And if you are doing something over again (and over again), then automate it. This is (one reason) why it is so difficult to estimate software effort.
  • A 10x developer is a code smell, and instead people should focus on building 10x teams

The last point on 10x developers was spot on when taken in context (as in someone that hoards knowledge as a means to give the appearance of being a super performer is a total code smell… but I would not call them a 10xer to begin with). I take the vantage point of antirex (among other things , the creator of Redis); much like we have brilliant artists, and pianist, and architects and investors we can totally have brilliant software developers, and part of their brilliance might be to make those around them also brilliant (but I wouldn’t call it a smell if they don’t).


When we look at who is attracted to Empex (and possibly Elixir in general), almost half of us have a decade plus experience in the industry; makes it easier to not feel so old I guess.

And in a twist of irony (I hope anyway), our post mortem was held here.

Happy Elixir-ing. See you at Elixir Conf 2017, I’ll be giving a talk on automation and immutable infrastructure for your side project.