After one year of abscence I was attending Fullstack London again. The past years were well-organized, fun, and had an awesome speaker deck on top of that. This year was no difference.
Here are some things I took away from these awesome three days.
Keynotes and workshops
The opening keynote was held by Douglas Crockford (the father of JSON) himself. While talking about numbers and their history he came up with DEC64, a new number type that fixes truncation and overflow problems (besides others) originated in the fifties. The session was not only informative but also very humorous as Crockford is often very opinionated and does not try to hide that at all. On top of that, Skills Matter gave away (among other things to choose from) Crockfords _The Good Parts_ book which he signed during the conference.
Later that day Amie D. Dansby, an Iot enthusiast and maker (with an RFID chip in her hand and a remarkable resemblance to NCIS’ Abby), gave an inspiring talk about releasing your inner maker. IMHO her slides where a bit overloaded but her spirit and message as well as the content (maybe because of the massive content) totally made up for that! She was also the one giving a hands on IoT workshop with Onion’s Omega2 development board. After DDoS’ing the conference’s Wi-Fi frequencies and some struggle for more space on the board I managed to get a working Twitter wearable displaying my latest tweet on an OLED display (and thanks to Amie’s patience).
Afterwards there where several tracks in parallel. No matter if it’s conference talks or festival bands: They’re either of the don’t-care-could-go-anywhere kind or you want to attend all simultaneously. As hard as it was I managed to single out some interesting sessions since I knew I could (and you can too) watch the others from the skills cast later.
Thanks to @thekwasti I recently started writing some TypeScript (or rather screwing with the TS he wrote). I also know decorators (for the spec has been deprecated and was still not reintroduced).
The most interesting example was a timeout decorator that could be used to let an async operation fail if it took longer than specified. Therefore, the decorator let the original async operation race against a delayed rejecting promise. If the operation completed before the rejecting promise it was considered successful. As soon as it took longer, the delayed promise would reject and fail the whole operation marking it as timed out.
npm vs gulp vs webpack vs what the heck!?
Although we’re using all of these tools in daily development and this was labeled a beginner session, Rubén Sospedra made you rethink the usage scenarios of the above mentioned.
It was no X is better than Y is better than Z talk which I was very grateful for. Every tool has its right to exist and should be used accordingly. Use npm for specifying simple commands or commands that trigger a chain of commands (a pipeline). Then specify complex pipelines with gulp (or any task runner that is hip at the time of reading). Finally, let webpack (or rollup or one of substack’s epic projects) take care of bundling your application.
Since the rise of Bitcoin everybody heard about crypto currencies and a mysterious construct that is the blockchain. IBM’s Kevin Hoyt did a great job demystifying this “distributed database with special properties”. And that’s what it is (basically). When you think about it, the whole Internet could be built on blockchain technology 🤔 😱.
Watch the skills cast, it’ll open your eyes.
Benchmarking and performance
There were two talks I attended that dealt with performance and how to measure it.
Sometimes measuring performance is art rather than science.
The above quote’s author Ahmad Nassri laid out a pretty relevant case of measuring function call performance especially in the time of AWS, Azure and GCE. The faster your function executes in these environments the lesser you pay. It’s that easy. Not only should benchmarking be part of the after-release phase (which is basically monitoring at that point) but also during the development cycle. However, do not overdo optimizing (especially not premature).
Martin Splitt, on the other hand, shed some light on browser rendering performance. He took the audience from 3 little shining dots all the way to how (and most importantly when) browsers are rendering a web page. Some explanations (especially GPUs and shaders) reminded me a lot of some profs’ lectures back at university (meaning he did a pretty good job IMHO). Best takeaway: Avoid the green rectangle of sadness! Avoid everything that makes the browser relayout or repaint (since these are the most expensive operations) but keep an eye on memory consumption.
Dragons in London…
…or how you should design an awesome test task to hire new developers. BigBank’s Nele Sergejeva was elaborating on mistakes you can make (as an interviewer as well as the one interviewed) when it comes to finding new developers (or a company to work for). She was (in either way) clearly advocating for story-telling. The test she presented was indeed way better than all I have done (or created) so far. It is not something abstract or technical but it gives you the impression you’re solving a real (well actually fictional) problem. Furthermore, it requires you to solve tasks like coping with REST APIs (and there sometimes interesting responses) as well as designing a simple algorithm. Especially when having started a new programming language this makes you dive into the fundamentals with a lot of pleasure and freedom (since the task is not as strict on how to exactly solve it).
Checkout how to help the Kingdom of Mugloar as Head of Dragon Resources Management.
- Callbacks? Sure, I heard there even was a hell for them.
- Promises? Doing that all day.
- Reactive streams? Recently tried some in Elixir.
- Generators? Yeah, heard they exist.
- Async/Await? Was experimenting with that.
What about croutines?
Well, turned out I didn’t know that the latter two are actually part of coroutines, and I used them without knowing.
It also featured the best explanation of
yield so far:
yieldis doing the same as a Mortal Combat fatality. It’s taking the promise and ripping out it’s heart (value).
Basically the talk was glueing together my knowledge (fragments) of async operations making me understand a lot of connections and things they all have in common (and share). Although Tomasz had to rush a bit during the end it’s definitely to recommend especially to people coming to node.js since it also explains the (simplified) workings of the event loop and asynchronicity in general.