Professional Go

Your customers expect reliable and tested code in their production systems!

In workshops, we teach the best ways to test and leverage the Go standard library first.

Hands-on Trainers

Workshops are conducted by seniors that work on advanced platforms everyday.

A proven track record for pragmatic and tested solutions, using their real life code examples when tutoring.

One week post support

Post workshop, we provide a week support for any remaining questions or topic.

Via video calls sessions we address together your challenges.

Audience

No prior knowledge of Go is necessary. But you are fluent in another programming language.

Objectives

By the end of this workshop you will have implemented advanced functionalities on a incrementally elaborated real life product.

You will have used key packages from the standard library, and learned how to compose them together.

You will be able to use the testing package in order to test your own code, and learn testing tips along the way.

Content

During this 2 days workshop, we will build together a incrementally complex devops tool with production quality code.

Along with you doing the implementation accompanied, trainers will provide help, hints to guide you and also demo the basics and key concepts in Go.

Testing packages

Testing is key in the Go ecosystem, and the standard library offers a lot.

We will ensure we go through all the often overlooked methods from the package that will make you testing code simpler.

Go system programming

By leveraging Go local system packages (os, fs, exec, signal, etc.), we will code reliable and simple solutions to interact with the local system.

It will show you how to to implement in the future your own awesome and testable CLI.

Functional principles in Go

By making function first class citizen, Go allow us to have better design. This is essential to sound Go programming.

We will leverage that to make our devops tool much simpler and with more flexible and open code.

Go tips & tricks

During those 2 days, many everyday tips and tricks from professionals will be distilled, the ones used at our daily jobs!

Integration testing

Learn how Go render integration testing easier.

Through the implementation of a real devops tool, let's ensure our code works with a few integration high level tests that will be simple and deterministic.

Demos and explanations

Intermittent to the coding of our product and tool, you will be able to sit back and watch demos and explanations on key concepts for your mastery of Go.

Audience

You have a good overview of what is Go but you have not used it much in production systems, and/or you have not leveraged yet all its package and powerful features as a language and ecosystem.

You want to start learning and/or improve your Test Driven Development in Go.

Ideally, you have completed workshop 1 and/or have an equivalent experience.

Objectives

You will learn to use less code to produce more robust production implementations.

We will leverage the standard Go library and it most important packages to the fullest, learning common and useful techniques and patterns along the way.

You will become a proficient Go tester of your own code.

Content

During this 2 days workshop, we will build together our own application with production quality code.

The application built will be multi faceted to allow for the learning of various powerful and common Go techniques, and therefore going over the most important and useful part of the Go standard library.

As of today, the Go ecosystem requires great knowledge in testing your own code! So throughout the workshop we introduce and teach you how to test drive your features professionally.

Test Driven Development

Throughout our workshop most of our features will be implemented using TDD techniques. We will introduce and explained how best to do that in Go using the standard library.

Master testing packages

We will learn how to leverage the various testing/benching package and concepts provided by the standard library. Automated/scoped cleanups, closure/scope data setup, temporary data, etc.

Robust and easy integration testing

Learn how Go has rendered third party, HTTP servers & clients testing a breeze.

We will build our own APIs and client in order to understand all the ways how to deal tests our HTTP services.

IO package composition

By building our own hasher program, we will learn one of the most important aspect of Go: IO composition.

Concurrency

By mimicking our own miner we will learn the necessary building blocks of various packages used for concurrency.

Professional Go tips & tricks

Going over packages, let's learn some useful and underused techniques that will make your code shorter and simpler!

Error management

How to simply handle errors and design encapsulated errors APIs. We will learn also what good logging is and errors wrapping.

HTTP APIs and JSON

We cover all there is to know about the standard library when it comes to JSON APIs as well as simple HTTP tracing, monitoring and race detection.

Design patterns in Go

We will learn important design patterns (GoF), how to apply them in Go and how they make your code more open for modifications.

Audience

Ideally, you have completed workshop 2 and/or have an equivalent experience. You know how to test drive your code (see workshop 2) and know how to use well the testing packages in Go.

Objectives

Within your backend team, take the lead for the advancement, design and testing of your Go codebase.

Learn new approaches and introduce your team to new ideas and practices that makes your product more manageable, testable, robust and simpler.

Content

During this 2 days workshop, we cover and use the patterns & topics described below in order to build our own production application along with the corresponding test suite.

Once learned, those patterns and topics can be replicated across a large number of backend challenges and issues.

Go generators

Go generators are often not well known and underused. They offer very robust features. We will use them to automatize part of our code.

Closures and functions objects

Learn how to use closure and function objects to your advantage. We will decouple our configuration and improve and testing in our application.

Testing APIs

Take integration testing to the next level! Testing APIs, will provide deterministic setup, automatic cleanup and scale when a large numbers of developers are writing tests.

We will build our own APIs and client in order to understand all the ways how to deal tests our HTTP services.

Testing, sub-tests and scope

Make your tests like specifications and leverage the scope to avoid data setup repetition.

Powerful tool from IO package

Mastering the Go IO package will allow you to implement more robust APIs for your production systems.

Interface segregation & embedding

Go beyond simple interface design to make your code and tests easier to manage. See how they fit with regular design patterns: template, etc.

Design patterns with Go

Learn how to leverage known patterns in Go: adapter, template, bridge, etc. For instance we will support a multi provider in our built application.

Third parties and external APIs

Learn to isolate your third parties clients with Go internal package mechanism to avoid coupling and leaking.

Encryption

Encryption is necessary in today's DevOps pipeline. Learn how to provide easy and robust encryption for production application operational pipelines.

Mocking pitfalls

Learn how mocking can degrade your codebase, and use alternatives.

Events with Go channels

Built an event driven pipeline in our workshop production code to learn how to leverage channel and the sync package.