This year’s dotGo in Paris was awesome. The people were great in general. The organisers and volunteers did a good job. The attendees that I interacted with were cool – I had some interesting conversations and made couple of connections. The talks were informative and engaging. If this is where you stop reading, please give dotGo a shot next year - I am sure it will be great! And please find me in the crowd and talk to me, because I’d love to talk to you.
If the first paragraph didn’t convince you, in this article I will share how dotGo 2019 went for me. I’ll try to cover multiple aspects of it: venue, general organisation, content, etc. After, I will share with you my four favourite talks of the day.
Keep in mind, this is all my perception of the conference and the talks. Feel free to politely disagree with me in the comments.
Since we were a bit late (arrived 30mins after the registration started), the registration went really smooth because most of the attendees were already in. We were greeted by the volunteers that registered us in and we got our lanyards from:
We did grab quite a bit fruits and coffee before the talks started, so we had enough energy to push it through until lunchtime. It’s worth noting that there was plenty of coffee and breakfast snacks to fill up everyone’s bellies before the talks started.
As a tradition, the dot conferences are organised in the beautiful Théâtre de Paris. Basically, what you should expect is a classic French theater that was opened in 1891. What I realised about conference venues in general is that theaters are the ideal for conferences: well lit, great acoustics, good seats and general layout.
I mean, look at this beauty:
And another view at the stage from my seat:
I rest my case.
The lobby was where the sponsors stands and the food were situated. This is what it looked like from the second floor looking downwards:
The conference had thirteen sponsors, where only five of them had stands. The stands were loaded with stickers (yay!) and other interesting showcases from the sponsors. We did chat with quite a bit of them, we even found an ex-colleague that works for one of the sponsor companies. So overall, the lobby was fun and always crowded.
My four favourite talks
dotGo had 17 speakers, out of which five did lightning talks and 12 had long-form (20 mins) talks. Every of the long-form talks had a short Q&A session right after with the MC of the conference - Dave Cheney.
Now, before I go on to list out the talks that I enjoyed most, I have to say that I enjoyed all talks and I believe that all were informative. Also, picking four talks out is hard. After the videos are out I will probably rewatch some of them – a change of heart is a possibility that I am not ruling out.
But until then, in no particular order, my four favourite talks of the day:
Bryan Boreham - Tune Your Garbage-Collector!
Bryan’s talk was about tuning Go’s Garbage collector. Go is a garbage collected language and while that brings a lot of ease of use for developers, it also has downsides. For example, if our programs use the memory in an unoptimised manner, Go’s garbage collector will have to do extra work to free up the memory that is not in use by our program.
If you’re not familiar with how the garbage collector can be tweaked, I
recommend looking at the
Tweaking of the garbage collector is done via the
GOGC environment variable.
This is what the documentation says on it:
The GOGC variable sets the initial garbage collection target percentage. A collection is triggered when the ratio of freshly allocated data to live data remaining after the previous collection reaches this percentage. The default is GOGC=100. Setting GOGC=off disables the garbage collector entirely.
While in the beginning Bryan starts out with a bit of theory (and a Java joke), the talk is very practical. He laid out three different memory allocation patterns and scenarios in which you might want to tweak the garbage collector:
- Memory allocation is high but stable over time, with no fluctuations. In
these scenarios he explained how we can make the garbage collector be more
sensitive to any potential fluctuations, by lowering the
- Memory allocation is small but rapid, which causes the GC to run many times
although the allocation is not excessive. In these scenarios, he explained,
we can make the garbage collector less sensitive to the fluctutations, by
400. This would make the GC wait for four times more memory to be allocated before it starts running.
- The program runs for very short time, so the memory allocation is not
relevant. In such cases, we can turn off the GC by setting the
off. One interesting scenario was compilation - if we turn off the GC when we compile our programs, we can speed it up at the cost of memory spent.
Overall, it was a very interesting talk that broadened my horizons on Go’s garbage collection and tweaking it.
Ellen Körbes - Building a dilator using Go
Ellen’s talk was probably one of the wackiest talks I’ve ever been to. Being a trans person, Ellen explained a very specific problem they have - how to build a dilator that they can make without a lot of effort. Obviously, they thought about 3D printing.
It was very interesting to see Ellen’s thought process, the inception (or rather the necessity) of the idea, finding ways to build the 3D model of the dilator using various tools before they settled on using Go for it.
I mean, no wonder - if I’d pick a technology to do this I would probably pick Go. Ellen said it best:
If there’s one talk I would recommend watching once the videos are out, it would be this one.
Ignat Korchagin - Go as a scripting language (in Linux)
Ignat’s talk was very entertaining. Being an systems engineer in Cloudflare, he wanted to use Go as a scripting language.
To achieve that, we embarked on a journey together. A thing to remember about
Linux scripts is, to have a program be executable as a script the first line of
the file has to be a “shebang” line. This line must contain the absolute path
to the interpreter that will run the file. The line usually starts with
The problem is - this works only for languages where
# is a comment, which is
not the case Go.
Our journey started with finding ways to hack the shebang line in his Go programs. He explained all of the weird hacks he had to do to be able to take the arguments from the command line to the program. Eventually, he took us for an even deeper dive into how Linux executes the scripts and how the kernel understands the shebang line to pick the correct executor of the script.
At the end we arrived at the destination - called
binfmt_misc. He explained
how this is solvable with a bit of kernel “magic”. Linux (the kernel) has a
which allows us to invoke almost every program by simply typing its name in the
shell. It does this by allowing the user to specify a handler that will know
what interpreter should run for a specific file type.
After that, I found another interesting
where the author explains the
binfmt_misc module and how they created their
own executable files using a
Overall, the talk was entertaining and I enjoyed learning a bit more about Linux (the kernel) and this specific module.
Marcel van Lohuizen - Errors in Go 2
Marcel works on Golang within Google, with focus on core libraries. His talk was about Go’s errors, where we are now, and how errors will evolve in the future.
Basically, Marcel’s talk was about Golang’s Design Proposal #29934, which touches upon two important aspects of errors in Go - inspection and printing.
The author team - Jonathan Amsterdam, Russ Cox, Marcel van Lohuizen and Damien
Neil - propose several additions and changes to the standard library’s
fmt packages. The goal is to make errors more informative for both
programs and people.
If you would like to explore the upcoming changes to the language, you can
check the new
xerrors package. The
package will support transitioning to the Go 2 proposal for error values. Also,
watch this space - I am already working on an article that explores the
proposal and the
dotGo 2019 was great
As you can see from the content, the venue and the organisation of the conference – I had a blast at dotGo 2019! The feedback from the community on Twitter also seems to be great. I personally think that all the speakers made a great job. The talks were informative, intellectualy challenging and entertaining.
I will be back in 2020, and I hope to see you there!
Liked this article? Subscribe to my newsletter and get future articles in your inbox. It's a short and sweet read, going out to +1000 of other engineers.
I care about your privacy, and will never send you spam. You can unsubscribe at any time.