This was a great opening talk. There is a lot of boiler plate involved in writing modern applications. Peter presented a tool that will write this for you.
Inspired by Rails, WebRPC will take a data type definition and generate boilerplate for Go and Typescript. With the monotonus parts of development taken care of there is more time for actually developing your application.
A highly practical talk for Go developers. Go routines are a light weight concurrency mechanism. Go routines are Go’s main selling point. They allow developers to use increasing core counts of CPUs in a simpler manner compared to most other languages.
Despite the simplification Go provides, there are still caveats. This talk provided a lot of proverbial advice. “Don’t start one without knowing how it will stop”, “Channels orchestrate, mutexes serialize”, “The bigger the interface, the weaker the abstraction”.
I’ve heard a lot about modules. This talk was a good introduction to modules and made them seem less intimidating than I thought. Educational, my main take away was a module being a immutable and unambiguous unit of versioning.
This talked showed off a lot of cool features of Auzure and VScode. Having VSCode run in a remote docker while having a thin client is interesting to me. I used Cloud9 before and thought it was a good service. Seems like you could do the same with VSCode with remote dockers
A quick post mortem style of talk. This was about an outage that happened at Shopify and what they did to prevent it from happening in the future.
In short, a Kafka cluster went down. When it came online it flooded downstream consumers, breaking many apps.
The solution was to add throttling to smooth performance and allow for auto scaling algorithms to do their job. They knew throttling was to be done earlier, but it was never a priority for them.
The library mentioned is small. I think it sets a good example of what documentation and proper test coverage looks like.
I have heard of the unsafe package before and figured “why would I use that?” and never investigated what it really was. I don't think I'll be using unsafe anytime soon, but I can see why people need it now.
We all know we should be writing tests. A good introduction to TDD with nice animations. This was about red, green refactor as your development work flow.
This talk presented some new ideas on tech hiring for me. The one I liked the best was the idea of a take home assignment that resembles a real code base, with tech debt and missing test cases. This helps better judge how a person actually writes code.
Another piece of advice is to time box it to a couple hours for candidates. Otherwise you favor those who have the most amount of time.
I read the blog post. Now I’ve seen the talk. Entertaining talk, I’ve seen too many of the patterns presented to believe its entirely satire though.
I’ve seen similar schemes to the one described in this talk. At first I was confused at the definition of the roles with a iota bitshift, I wasn’t familiar with the pattern. The combination of a slimmer JWT token, a performant one line permission check made this an elegant solution.
I knew of bitwise operations but have never used them, this talk showed me why they are useful.
I have heard a lot about web assembly, but have never looked into it. This talk gave me a much better idea of why bothering about web assembly. I went home and google more into web assembly. While you can target WASM with go it seems to loose most of its benefits in its current state. With 2MB minimum file size it. It seems like tinygo might be able to alleviate this.
One of the arguments for WebAssembly is that it gives developers freedom of language, but that languages that can target WASM seem limited to me https://github.com/appcypher/awesome-wasm-langs.
At any rate trying to put this talk in context has made me learn a lot more about lower level stuff than I am used to looking at.