My First dotGo Conference

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!

Source: Ilija Eftimov