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.

Registration

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.

The venue

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

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 runtime package. 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:

  1. 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 GOGC value from 100 to 50.
  2. 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 increasing the GOGC value from 100 to 400. This would make the GC wait for four times more memory to be allocated before it starts running.
  3. 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 GOGC value to 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:

Another thing is: this is JavaScript. And I am NOT sticking JavaScript in my body.

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 module called binfmt_misc (docs) 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 article where the author explains the binfmt_misc module and how they created their own executable files using a #!~[TODO] shebang.

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 errors and 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 xerrors package.

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!