Trondheim Frontend Best of Conference

The frontend group in the Trondheim branch of BEKK recently had a meeting on the topic Best of Conferences with 4 selected presentations after a CFP. In this post we have summarized all talks and shared our opinion on them.

In BEKK we have several different special interest groups (Competency Group), ranging from emerging technologies to project lead and frontend development. These groups have monthly meetings with varying topics and different formats like workshops, presentations or discussions. The frontend group in the Trondheim branch of BEKK recently had a meeting on the topic Best of Conferences. Before this meeting we sent out a “Call for Presentations” where all the members suggested their favorite video of a conference talk. 19 talks were sent in and a committee selected 4 of the presentations for our “Best Of” session. In this post we have summarized all talks and given closing notes on whether or not you should watch them.

Simplicity Matters — Rich Hickey

Simplicity is a prerequisite for reliability — Edsger W. Dijkstra

This presentation focuses on the difference between simple and easy. Easy is convenient for developers, but simple is less complexity through not complecting the code. The presentation starts fairly slowly, with Rich Hickey explaining what he think of as the differences between simple and easy. He goes on to talk about people having limited amount of concurrent thought — and thus, there is a limit to how much complexity we can handle.

He explains, the problem we have is that we often think of what is easy for us to do now, but this can lead us to introduce complexity. While it may be working now, it will cause a propagation of complexity down the line. The end result will be that we no longer have control of our application, and we won’t be able to extend, change or add functionality with confidence.

By the middle of the talk, Rich Hickey gets more technical and show examples of unnecessary complexity. One example shows how order matter. In many cases, order doesn’t matter, so instead of having structures where order plays a role, we should use things like Maps. Maps might not be easier to use as developers, but the application will be less complect.

In Brief

  • Simplicity requires efforts and love
  • Simplicity is not easy
  • Unit tests, integration tests, etc, doesn’t care about complexity

– Summary written by Pål Thomassen

Our Thoughts

A timeless talk which applies to every developer, no matter the discipline. The talk has many good examples and illustrates his points fantastically by good analogies. Although it starts somewhat slow, it picks up and by the end Rich Hickey is really engaging. This is one of those historic talks, making ripples through the industry and is definitely a must-see.

How Designers Destroyed the World — Mike Monteiro

Mike Monteiro talks, in a somewhat grandiose and not-so-flowery manner, about designers who don’t take responsibility for the things that they create. He starts out with an example of how a seemingly insignificant design decision changed the life of a young girl in a negative way, and continues to talk about how this all could have been avoided if the designer had taken a conscious and deliberate responsibility for the design.

He talks about how designers all over the world works on projects without giving any thought to the impact it has on the world around them, and how this needs to stop.

Only by taking a conscious and deliberate responsibility for what we create can we help people avoid mistakes, and make this world a better place to live in.

– Summary written by Bendik Solheim

Our Thoughts

You can really tell that Mike Monteiro is very passionate about the subject and that this talk is a personal one. He has many great points and raises some important problems with the industry. All in all an inspiring talk relevant to a much wider audience than only designers. The message in this talk is a really important one, and it makes this talk a must-see for all. This is also reflected in Monteiro winning the Conference Talk of the Year at the Net Awards 2014.

Putting The Dream Machine To Work — David Nolen

This talk is mostly about data structures, but starts with some brief history about J.C.R Licklider, the writer of the book with the name of the talk (The dream machine). Nolen means this is one of the best books that describe how interactive computing came to be.

From the perspective of MVC, he says that Licklider had some good ideas about creating user interfaces based around Tries. To understand the idea of Tries, Nolen starts by explaining the concept of functional programming and immutability.

An immutable value is a value whose state cannot be modified after it is created. In Java, strings are examples of immutable values. Nolen comes back to tries and he explain how Tries work with comparing it to a Linked List, where a value x and y that point to the same list share memory. This concept of sharing memory is called structural sharing which is space efficient and avoids the need to copy entire objects.

Nolen gives an example of such a data structure by describing the concept of bitmapped vector tries. It’s a data structure where the data lives in the leaves and make data accessible in a bitwise way.

He continue with some live speedtests, comparing a regular array with an immutable vector and show that immutable vectors can be just as fast and in addition gives you the power of immutability.

“Om” is a ClojureScript interface to Facebook’s React. He explains how React is using immutable data and how easy it is to implement redo/undo logic in your user interface. He also talks about his library mori, which is a simple port of ClojureScript’s persistent data structures to JavaScript. The data structures described earlier is available in mori persistent data structures.

– Summary written by Emil Andreas Mork

Our Thoughts

Overall it’s an OK talk describing some of the concept and power of persistent data structures, with some history involved. The common thread is not very present and it really feels like David Nolen tries to put as much words as he can within half an hour. There are better talks about the concept out there, even by David Nolen. Another alternative is Lee Byrons Immutable Data and React from ReactConf 2015. This particular talk, from JSConf 2014, isn’t really a must-see, but you should see other talks on the subject if you want to get familiar with immutable data as an architectural pattern.

What the heck is the event loop anyway? — Philip Roberts

A ~25 minutes talk from the 2014 edition of JSConf EU. It goes into depth on what exactly the eventloop is and how it’s relevant for JavaScript developers.

The talk goes into how the JS APIs that we as developers use is actually handled by multiple different sub-systems, one of which is the runtime (for instance V8). It covers how asynchronous calls are actually handled and how a callback-function differs in behavior when used asynchronously and synchronously. It covers terminology which is often used, but not always thoroughly understood. And it does it all with a great and clever use of visualizations to aid the understanding.

– Summary written by Stian Veum Møllersen

Our Thoughts

A definite must watch if you are using JS on any level, beginners and experienced developers alike. It will help you understand or further cement your understanding of the environment in which your code is being run. More technical and practically oriented than the other talks in this session. The information provided is of high quality and extemely useful for a talk of only 25 minutes. This talk is a definite must-watch for any JavaScript developer.

Closing Notes

Having a mini-conference like this worked out really well for our group. In addition to the value from the presentations themselves, we got some really good discussions going. Sometimes we got so exicted and energic we didn’t have the spare hands to take notes.

Simplicity Matters is a must-see for general software development, How Designers Destroyed the World is a must-see for any designers (software design included) and people in general, while What the heck is the event loop anyway? is a must see if you work with Javascript (in the browser or on the server side) or you just want to learn more about the event loop. The specific talk Putting The Dream Machine To Work of JSConf 2014 isn’t a must-see, but there are many other good talks by David Nolen or about the subject that is worth checking out.

If you have any suggestions for our next Best of Conference or responses to our summaries, feel free to post a comment below.

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.