strange loop 2014

Each year I look forward to the Strange Loop Conference in St. Louis, MO because it always expands my mind and connects me with those that are really shaping the future of our industry. The first talk that sparked some serious thought was Joe Armstrong’s keynote.

Meta Information

  • Author: Jeff Barczewski
  • Published: October 7th, 2014
  • Tags: strange, loop,software,craftsmanship

The mess we’re in - Joe Armstrong

Joe Armstrong, Erlang’s creator, started off the conference with the opening keynote, titled “The Mess We’re In”. Joe took us on a quick journey from the past to the present to illuminate how things have changed in the world of programming.

  • No common language - in the early days, a programmer only needed to understand a few languages and DSL’s (sh, C, make). Today one needs to know so much more (C++, Java, HTML, XML, CSS, Javascript, Grunt, …)
  • Lost context - when we are in the midst of creating the program, the context of the problem and all the requirements are clear to us, however if we don’t document them in comments, specs, and books, everyone who comes later will struggle to understand the reasons behind the design. Even revisiting uncommented code we have written a year later can be painful.
  • Rush to market - the current trend has been to continue to ship code more rapidly each day, to beat out the competition. Instant gratification is the current mantra of today’s society. This has led to code being shipped before it is really ready or beautiful.
  • Legacy code - the industry is full of legacy code that is fragile, has little documentation and few tests. Code whose authors have moved on to other things. The path forward for this code is slow and treacherous.
  • Complexity - distributed, parallel computing, concurrency, massive data all have added to the complexity we have to deal with. A 32 bit integer can represent more permuations of state than all of the atoms in the earth.
  • Duplication - as programmers we know that copying code from one place to another is bad, since it becomes hard to maintain, yet how many times do we create the same bit of code or library? Forking code has become so easy with things like GitHub. With so many modules, which one should we use?

Understanding is the first step in finding a solution. I believe taking each of these issues to heart as we approach our development, we can improve the situation to some degree.

Some easy direct actions we can derive from the issues are:

  • Creating more documentation, training, books. I’ll be personally working heavily on this with my CodeWinds videos and tutorials.
  • Trying to finish code (make sure it is ready and complete before moving on to something else)
  • Reducing complexity where possible
  • Tests around the public interfaces help prevent regressions and empower refactoring
  • Promoting reuse, work with authors to contribute back to existing projects rather than always forking or building new projects

However with all of these actions, I believe still more is needed.

So the question is posed to you, how do we attack each of these problems head on and prevent the apocalypse of unmanagable code being handed down to the next generation?

[Watch Joe Armstrong Keynote on Youtube](https://www.youtube.com/watch?v=lKXe3HUG2l4)