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.
- 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
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
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.
– Summary written by Emil Andreas Mork
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
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
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.
If you have any suggestions for our next Best of Conference or responses to our summaries, feel free to post a comment below.