Abstractions Conference: a retrospective on the current web

In late August, four of us from Dynamo went off to Pittsburgh PA to attend Abstractions. The conference was sold as an intersection between everyone involved in building the modern web. Since this space is quite near-and-dear to our Dynamo hearts, we thought it would be a great place to see where the web is headed in 2016 and beyond.

Overall, this was a massive conference, with four days of speakers from 9 am to 8 pm, spanning four different disciplines. There was never a shortage of talks and often very little time to grab a bite to eat during down times. After listening to over twenty talks spanning all four days, there were some very clear takeaways from the folks who are building and designing the current web.

Takeaway 1: Functional programming is not a fad (yet)

If you’re looking for a conference that gets down and dirty with code, a la Codemash, Abstractions might not have been a great choice. Overall, the schedule was sparse when it came to languages. The talks that were about a language, however, were predominantly those of a functional nature. The top three being Elixir, Elm, and everyone’s favourite: JavaScript. Although, if you’re a fan of objects, the wonderful Sandi Metz was there with a great talk on code smells.

It would appear that the functional world of programming, once jailed to the world of academia, has made a triumphant escape. Folks seemed generally interested and chatty about Elm’s architecture, the concurrent power behind Elixir, and the ease of programming that comes from a bag of functions versus one of classes. Being somewhat impressed by the ecosystem surrounding Elm and functional/reactive programming, there is definitely space for this in today’s world of muddied class names, and object responsibility juggling.

Many of the rest of the programming talks focused on the history of programming - where we have come, especially concerning the Javascript ecosystem, and where things might go in the future. These lighter talks were a good break from the more technical, language specific presentations.

Takeaway 2: Feelings are a valid feeling

Speaking of the softer side of programming, many talks touched on the term ‘happiness’ — specifically, focusing on how to better find ‘all the happiness’ in programming. A lot of this happiness focused around APIs which have been a focus at Dynamo for some time, while others focused on mental health issues, which sometimes takes a back burner in web development and design.

Regardless of what part of the web you build, happiness and health should be top of mind. Unfortunately, these softer talks so rarely get added to conference schedules. This omission leads people in the industry to talk about these intensely important subjects only in backchannels, or in small group settings. Talking about this in smaller settings often provides short term relief, but can lead to invalidation. Opening so many talks up to these concepts during Abstractions really legitimized that we, as group of people, need to take happiness and health seriously.

As an active / aspiring speaker in the community, I’ve noticed many active calls for papers at conferences in 2017. If you feel as strongly as the folks at Abstractions about this subject, I would highly encourage you to submit a talk. The worst thing that could happen is that conference organizers shoot your proposal down.

Takeaway #3: Containerization is the way forward

Containers, the Docker kind, are still quite hot when it comes to the world of DevOps. Although several of the conference sponsors profited from these types of talks, there was a still a good amount of chatter in the halls about this controversial topic. DevOps is super hard, and doubly so with a distributed application architecture. The hope that Docker (and its competitors) aim to create, e.g. build once and run anywhere, is still top-of-mind for engineers.

After listening to a few container specific talks, it’s abundantly clear that there are many players in the container space. The struggle is real when striving to deploy a swath of mini applications, that all talk together and rely on one another. It’s one of those technologies however, that has yet to ‘shake itself out.’ From a builder’s standpoint this is a little insane. I’m not interested in deploying an app to production only to have a management layer/company dissolve it days later.

Takeaway #4: There are some fun talks on the way

Many of the talks that we heard throughout Abstractions, I have yet to hear on Confreaks.tv or Youtube. There is likely a very good reason for this: many circuit speakers will introduce new and experimental talks at these smaller conferences. Afterwards, they will judge how well it went, take the pulse of the audience, and especially note the reaction of the other speakers. They will then tweak as needed, and resubmit the talk to bigger, more renowned conferences. Almost all of the talks that I attended were very well thought out, and would have drawn just as much of a crowd anywhere else.

Takeaway #5: There is plenty of space for the generalist

There is plenty of space for these larger scale (Abstractions had 6 tracks) generalist conferences, the ones that don’t specifically focus on a single topic, like RailsConf or RubyConf. AllThingsOpen, another large, generalist conference has been going on now for several years. The first few editions were rocky, but the last few years have attracted a phenomenal number of great speakers. These larger scale conferences often take several years to get the hang of things. This was the first edition of Abstractions — and with all the technology happening around Pittsburgh, it has plenty of room to grow.