Gophercon UK 2023 throwbacks

Thanks to Leboncoin, I could attend the 2023 edition of the Gophercon UK. It was a great and enriching experience, especially as it was my first developer conference.

If you are able to attend to a Gophercon or similar conference, and you are definitely passionate about software, I highly advise you to take the leap. Attending to such an event, I could:

• Broaden and deepen my knowledge about topics around Go or software in general
• Get to meet awesome people that are passionate about their craft and sharing knowledge
• Find myself in an environment where ideas and talks about tech were fusing

Workshops, talks & keynotes I followed #

Ultimate Service with Kubernetes #

Presented by William Kennedy, this workshop guided us through the development of a basic web server with logging running on k8s.

The whole day was filled with practical advices:

• On how to architecture our services with layering.
• On how we’re not aiming to make things easy to do, but easy to understand, since the latter will be easier to debug, modify, maintain, etc…
• On how we should aim at precision, meaning we should avoid all super flux interfaces or complexity

Locally, the service was running with kind. The repo can be found on GitHub.

Memory Management in Go: The good, the bad and the ugly #

In this talk, Liam Hampton a cloud advocate at Microsoft gave us a brief refresher about the what and how of memory and its management.

He then proceeded to share with us the specifics of memory management in Go, how to find and avoid memory leaks, and how using the pprof package could help us monitor our application’s memory usage.

After that, he advertised to us some Microsoft tools around AI (ChatGPT & GitHub copilot) as a way to help us write code that makes better usage of memory safely. This last part confused me as it seemed out of place.

Monolith or Microservices or Both: Modern application development using Service Weaver #

Robert Grandl, a Software Engineer at Google, presented us the Service Weaver framework, a solution from Google which simplify the decoupling and deployment of microservices.

Actually, the description of the value proposition is:

“Write your application as a modular binary. Deploy it as a set of microservices”

Basically, you write your application from the ground up like a Modular monolith, with components, without worrying about them communicating. Then service weaver generate code that decouple the components and allow a single deployment of the multiple components isolated from each others on different machines.

Some issues of this could be that components cannot be shared into multiple deployments (else, if you want a common component in two different deployments, you’ll duplicate it). Or that we cannot gradually migrate towards this solution, mostly because of the way the communication between the services are handled.

According to some comment on Reddit, this is the open-source equivalent of the main application development framework internally at Google, which is told to be working exceptionally well, and at scale.

Although I didn’t grasp the entirety of this talk and the concepts, it was one of the best talk I’ve followed at the GopherCon, and the solution seems very promising to me.

Fun with Algorithms and Data Structures #

This was a simple but very clear and welcome refresher on DS & Algorithms. Not necessarily linked to Go in particular, beside the fact that the implementations were in Go.

The speaker, Beth Anderson, explained to us multiple concepts:

• Node chain
• Linked list
• AVL tree
• Stack (LIFO)
• Queue (FIFO)
• The Heap
• The graph and the Dijkstra algorithm

Level-Up Real-time Go Applications with Ringbuffers #

As seldomly work with lower level components in programming, the concept of circular buffer, also called ring buffer, was pretty remote to me.

Fawaz Ghali presented us this data structure, and how it is an ideal candidate for publish and subscribe or efficient data replication use cases.

The context package internals #

In this talk, Damiano Petrungaro dived with us in the context internal package, to explain how the provided Types worked, and how it manages the cancellations and deadlines in the applications.

I honestly never dived into the context package, and it stayed pretty abstract to me, despite its simplicity. So this talk was a great and very welcomed refresher. Especially since it was great to follow, as the speaker was dynamic and passionate about sharing knowledge!

Zero Trust Security for your APIs #

I was pretty confused by this talk. I expected to learn many concepts about API securing, but in the end it felt like we stayed on the very surface of the topic.

It was told that we should have a zero trust policy with our APIs, should always verify the calls to it, and that the mean of achieving it was to use JWT on our REST API endpoint.

After that, the presenter started a docker container, which set up a REST API. Showed us how anyone can call it, which is bad. And then they connected the application to their SaaS, Mulesoft, from Salesforce. Which enabled JWT authentication. I felt lack there was a lack of substance in this talk during it’s 45 minutes duration.

State of the Go Nation! #

This talk by Cameron Balahan, product lead for Go at Google, was about how the Go programming language was still growing in popularity among developer, for its usage but also for the developer satisfaction.

One important takeaway from this talk was that Go 2.0 will never happen. As the Go team doubled down on backward compatibility, Go is backward compatible since Go 1.0, and forward compatibility is considered important.

Understanding Language Server Protocol - autocomplete, formatting #

This talk was given by Adrian Hesketh, and it was meant to help us understand LSPs by building one of our own.

The LSP that was demonstrated to us during the talk was for an imaginary language, cooklang. And we went through all the steps to enable & disable our LSP through the APIs of modern IDEs/text editors: NeoVIM, VS Code & Intellij.

We saw how the LSP and the editors communicated, either with a simple request/response dialogue, or through notifications (for actions in the editor, e.g: opening new file, save, added char). And that by sending jsonRPC with unique IDs.

It was a passivating and insightful talk. I am very thankful for the presenter to share with us this type of information with such passion.

The Adventurer’s Guide to Forking the Go Runtime #

There exist quite some forks of the Go runtime already: Embedded Go, a Uber one, a Microsoft one…

The goal of this talk, given by Dominic Black, was to show us how powerful forking the runtime of our programming language can be. We were shown how it allows us to add functionalities, such as distributed tracing, and without modifying a single line of code on our application.

Boosting Test Coverage for Microservices #

In this talk, Laura Vuorenoja explained the what and how of test coverage, how to measure it in a go application and how it helped find untested cases in her company.

This subject feel like is already known in most of the cases by SWEs, and in a lot of cases code coverage isn’t even an important metric to look at, or at least it shouldn’t be a northern star. But the information given in this talk were still valuable and very welcomed.

Make developers fly; Principles for platform engineering #

A great talk from Mahavir Teraiya, a Solution Architect at AWS, about a topic that is usually misunderstood: platform engineering.

This one was pretty important for me to follow, because working as a backend SWE in the Search Feature team at Leboncoin, I am working in a platform team. What we work on is used by the frontends, but also, and in great part, by the other backend teams.

As a platform engineer, your goal is to reduce the cognitive load of the other teams, with tools, services and other artifacts that ease their work.

Producing good documentation is part of the tasks, as well as templating as much as possible. These will lead to one of the most important concept as a platform engineer: creating Golden paths. These are simply paved down paths, that tells how things should be done.

A good platform should tend to fit some principles: V.D.U.C.T.S

• Versioned
• Decentralized
• User-centric
• Customizable
• Transparent
• Self-Service

We can look at AWS products like Proton to get the idea of a platform that has been developed to respect best the above principles.

Incident Management - Talk the Talk, Walk the Walk #

In this talk, Hila Fish explained the proactive routine engineers should have to smoothen incident management for when it is really needed. She also came up with a list of best practices to respect during incident management, in order to stay calm, be rational, and straightforward about solving the issue.

During an incident, that is, during a loss of customers, revenue, or data… every noise is amplified and managing the incident is key to minimize any loss. I haven’t solved many incidents myself yet, as my more experienced colleagues often take the lead and are way more precise, which makes them way faster. But learning from the experience of others is key for this type of tasks.

General feedbacks #

• The environment was stimulating for ideas and to create conversations around software development and Go. Meeting passionate people and following talks about subjects I haven’t explored yet was both challenging and rewarding.
• Some talks felt like a promotion wrapped into a thin layer of educational content. It is pretty common nowadays, but at a paid conference, and also in contrast to the information rich talks, those left a bitter taste.
• There was unfortunately a great disparity of complexity and expect developer experience between the different talks. And it was something that we could hardly infer with the name and the description of the talks (which were not included in the planning brochure, only on the website).
• The overall experience was lovely, as everything was taken care of to allow the speakers and the participants to focus as much as possible on the subjects of the conference.
• A lot of interesting and challenging talks, which were really rewarding to follow.