DotGo 2019 - Paris

“To like many people spontaneously and without effort is perhaps the greatest of all sources of personal happiness.” — Bertrand Russell

Eurostar 🚅🇪🇺⭐️

The adventure begins at St. Pancras train station, where I randomly bump into Kat: what a nice coincidence to start!

After some deep conversations that could have led us to designing a decision tree for ranking pastries (almond vs. choc/hazelnut croissant vs. pain au chocolat), the platform was announced and Kat and myself boarded, respectively, carriage 4 - seat 4, and carriage 5 - seat 67. Here 👇 is a thread should you want to know more.

A rather seamless journey brought us to Paris, Gare du Nord 🎉. It didn’t take us long to get to the Hotel where we had an excellent reception by the Happy Culture hotels staff.

Paris Gophers 🇫🇷

While Kat was reviewing the slides, a message comes from Roberto which could be summarised with “does anyone want to get a drink?”. So, while Kat decided to get ready for the speakers dinner, myself and Roberto headed to the 10th arrondissement where the venue that would host the “Bring the cool back in the cloud” was.

It was great to hang out with the Paris Go community; very interesting lightning talks in a welcoming venue with top notch organic blanche beer 🍻 to quench our thirst, and french baguette 🥖, cheese 🧀 and jam to keep us well nourished.

A collection of moments from the night is 👇

dotGo - Paris Theatre 🥰

The venue is just beautiful, one of my favourites, if not my favourite so far. It has hosted us for a few years, and hopefully will continue doing so.


I really like the dotGo format of a single track conference, with “ted-like” talks and quite long breaks to allow people to socialise without having to keep an eye on the watch not to miss the next talk. In addition to this, the organisers kindly encouraged the audience not to use any laptop - and ideally any phone - and just enjoy the talks: this is made easier by long breaks between the talk sessions, as everyone has time to catch up with their digital alter-ego during the break, and enjoy the conference and the talks the rest of the time.

Another interesting aspect of the conference is that the attendees will only know which speakers will take part to the event, but nothing about their talks. It might sound weird, but it feels, somewhat, right.

But moving on: breakfast time looked already quite busy, and so did the theatre at the beginning of the conference.

The talks 🗣

Due to Eurostar panic I’m utterly gutted I missed the last two talks of the day.

Follows a brief summary of what I attended and - where possible - some links: I’m sure videos will be published at some point in the future by the organisers.

Optimizing Go code without a blindfold (Daniel Martí)


I know Daniel from the London Gophers meetup, as he’s been one of the most active gophers! A great person who in my opinion embodies the values of a community member and contributor. I got used to always expect something insightful from his talks, and I never get disappointed, including this time.

Daniel presented in his usual very informal and pragmatic style how important it is to be rigorous when it comes to measuring performances (if those really matter!), and take into consideration all the possible side effects and variables that could play a role in the process. He gave a few concrete suggestions on the steps that should be considered when measuring performances of a program, and gave a few insights on how the compiler optimises some code (and how it’s getting better in doing so!) if you know the tricks.

That day I learnt:

// replace a map
m = make(map[string]string)

// clear a map; faster since Go 1.11!
for k := range m {
	delete(m, k)

Hashtag #TIL (that day I learnt…)

How do you structure your Go apps? (Kat Zień)


As Daniel, I know Kat from our London Gophers meet-up, of which she happens to be also co-organiser. It’s always great to hear from her about software design and follow her research through the history of design patterns and how they could be implemented without giving up on the “idiomatic Go” approach.

Kat went through the discovery and re-discovery of the hex/onion/ports-and-adapters pattern, discussing the advantages with a focus on the maintainability of a system, getting there through different testing approaches (and how they relate to each part of the hexagon).

Takeaways: start simple, evolve over time, and be like water.

Hashtag #organisedsimplicity

Better x86 assembly generation with Go (Michael McLoughlin)


This was the first time I listened to a talk by Michael. After the first few slides where I felt a bit lost not having used assembly in Go, and expecting something somehow inaccessible, I was positively surprised by realising that it all made sense! Michael explained how the Go standard library still relies on Assembly (especially some packages, like crypto), and suggested a solution to the problem he identified, which is mostly the maintainability of the Assembly code.

He recognised that sometimes using Assembly will make sense, but at the same time it would be great to have a way to generate robust Assembly with Go itself, which is why he came up with the idea of “Avo” (loved the pun “I also Avo a logo for it!”).

Hashtag #baremetal🤘

⚡️Distroless docker image (Joan López de la Franca)

This was the first of a series of lightning talks after lunch.

Joan gave us a brief introduction on Docker images/containers, and introduced the audience to the concept of a “distroless” docker image (more details here) that can be used to prevent access to the container via bash (as a distroless image doesn’t have shell or any package manager).

Hashtag #braceyourself

⚡️ Neural networks made easy (Olivier Wulveryck)


Nice introduction on how developers can use neural networks by writing Go. Olivier introduced us to the ONNX open format and the onnx-go implementation.

Hashtag #🧠

⚡️ TensorFlow and Go (Natalie Pistunovich)

[slides coming soon]

I met Natalie a few times at previous Go conferences, I believe the first time was Fosdem a few years ago, and then of course in Iceland as she’s the organiser of the wonderful GopherCon Europe (which this year will be in Tenerife).

Now, here’s the gist: she managed to explain me what Tensorflow is, why should I care, and how can I start, and all this in 5 minutes.

I’m not going to lie, I’ve heard about tensorflow in the past, I knew what it’s used for (kind of), but this talk was, in its simplicity, just perfect. After the talk I felt like this:

So, thank you Natalie 🙏

Hashtag #crystalclear

⚡️ The monsters inside the sync.Locker 🔒 (Roberto Clapis)


I met Roberto at GopherCon UK in 2018 (check out his talk about concurrency!), and ever since a good pint has become a regular habit when we we get a chance to get one!

In his lightning talk this time Roberto explored with the audience the internals of mutexes explaining how they make use of the atomic package, and why it’s important not to mess with it! Mutexes in Go take care of using atomics in a concurrently safe way, which is not necessarily what you might end up doing should you decide to do it yourself! So don’t!

Hashtag #canttouchthis!

⚡️ Swimming Pool Semaphores 🚦 (Valentin Deleplace)


This is one of those talks that by taking advantage of some basic visualisation techniques can clarify some well known concurrency patterns way better than anything else. It’s a talk about how to implement semaphores by using the analogy of a swimming pool. I’d recommend this presentation over a bunch of books if you’re short on time!

Great idea, simple implementation, and slides are rendering real Go code… 😱

Hashtag #humanconcurrency

Constant time ⏲ (Dave Cheney)

[slides coming soon]

Dave is a well known member of our community, we recently had the pleasure to host him at LondonGophers where he gave a talk titled Absolute Unit (Test), and for this edition of dotGo he’s also acted as MC for the entire day, interviewing the speakers after each session.

In his talk Constant time, Dave accompanied the attendees throughout the discovery of some variables - he analysed for example some of the “sentinel errors” that we use everyday - that should probably, by design, be immutable. In these scenarios a const would guarantee that the behaviour of your software won’t change in case someone decided to redefine the value of a sentinel error to nil, being able to bypass, for example, some if err == rsa.ErrVerification {. In some cases it could make sense to define a type alias for a string that implements the error interface, and use it as a const making sure that it cannot be altered in any way.

Hashtag #zerotrust

Multi modules repositories (Jean de Klerk)

[slides coming soon]

Jean, after a brief and very clear introduction to Go modules, and how they relate to the most common and basic use case of “one module per project”, showed us how a “one module” project could potentially evolve by promoting its own subpackages into self contained Go modules, and how this affects the versioning of each one of them. In addition to this approach, he also gave some hints on how to solve possible shortcomings of tagging a module in the wrong way.

Jean also explained how modules will allow circular dependencies, as opposed to what has been so far.

Hashtag #byebyemaster

Get Going with WebAssembly (Johan Brandhorst)


Another familiar face from London Gophers on the dotGo stage, this time Johan after a quick introduction to WebAssembly and TinyGo showed how the two things could work well with each other: first speaker of the day to run a live coding session on stage, after a simple example of compiling and consuming a wasm binary, he moved to more complex examples and demonstrated how TinyGo could massively reduce the footprint of the file, from MB to KB. He also briefly explained what the limitation in TinyGo are right now, and encouraged the participation to the Gophers Slack channels #webassembly and #tinygo.

Hashtag #wecangoanywhere

Tuning Go GC Parameters (Bryan Boreham)


Go, as opposed to Java/JVM, doesn’t offer many options to tune the Garbage Collector. In fact it only offers one, opportunely named GOGC. This variable can be set to the value off or to a number, by default 100: this default value means that the GC will allow the heap to grow up to 100% the current value before kicking in and collecting all the unreferenced objects. In his talk, Brian showed in which context it could be useful to tune this value, depending on the specific scenario we are dealing with.

He added a nice recap table at the end of the slides, which I currently cannot find!

Hashtag #keepitclean

Generate and render 3D mesh with Go (Ellen Körbes)

Ok, this was the talk with the most shocking opening and the funniest closing I’ve seen. Probably ever.

The first slide was this 👇

The reason for this introduction was - partially - to explain where the main idea came from, which is the need to be able to 3D print a vaginal dilator, but I must admit that it was like watching a movie where literally anything could happen. After the formulation of the problem, they explained the process behind the implementation of the solution (apparently partially solved with JS), after the epic:

“I’m not sticking JavaScript inside my body”

Their talk was the second one with live coding on stage, and step by step they showed the possibilities unlocked by some Go libraries for 2D/3D modelling and rendering, starting with the example of a Gopher, moving on to the dilator model, and closing - amongst the most spontaneous laughter of the day - with the mesh of the two.

Irreverent and fun, Ellen managed to bring the audience along a journey that goes way beyond the technical aspects of a programming language in a beautiful mesh of code and life. 👌

Hashtag #nojs

Shattered Mirror: An Introduction to Reflect and Unsafe in Go (James Bowes)

In his talk James explained how the implementation of a workflow in Go led his team to develop a solution that made use of the reflect package, and the shortcomings that they encountered along the way. In doing so, he also dived into the unsafe package explaining how the two interact with each other.

Hashtag #safetyfirst

I unfortunately missed the last two talks, by Jessie Frazelle and Marcel van Lohuizen due to the risk of missing my last train back home, so if anyone wants to contribute, please do so by opening a PR on this repo.

Equally, if any speaker wants to ask for some changes or amends on anything from this post, feel free to contact me and I’ll be happy to help.


This was my second dotGo, and I’m already looking forward to the next edition, on March 30th, 2020!

A final thank you to the organisers of the conference - we all know how stressful this can be - and to the speakers who performed bringing their best self on stage. Thanks to the sponsors who made this possible and, last but not least, to everyone who showed up, some from the other side of the city, some from the other side of the world. It’s been a pleasure spending this day with you all, and I look forward to crossing paths with you again.

Until then, farewell, and don’t panic()!

comments powered by Disqus