Agenda | GopherCon 2021

Level: Intermediate/Advanced

Description: 

Can you encode binary data in JSON? Which serialization formats can you use to exchange data between Python & Go? How can you distinguish between missing data and zero values in incoming requests? What will reduce bandwidth and CPU when passing data between services?

In this workshop, at the "edges" of your program (e.g. when interacting with other services) you will use serialization to send and receive data. You will learn how to work more efficiently with serialization to make your interfaces more flexible, which will save you money on CPU & bandwidth, and free up your time to focus on writing business value code.

What a student is expected to learn: 

We will discuss the need for serialization, as well as some theory and best practices. You will also discover how to pick a serialization format that fits your project.

As an exercise, students will write an HTTP server that serves weather data in various formats. We will start with JSON, move to Protocol Buffers (protobuf), and if time permits, we will work with other formats as well.

By the end of this workshop, you will know how to work with serialization effectively and how to avoid common mistakes.

Prerequisites: 

• You should know how to program in Go and have some experience with the command line. 
• Some experience with web APIs and the net/http package is a plus.
• You will need a working Go environment and an IDE such as VSCodeor GoLand. 
• You will also need the protoc protocol buffers compiler on your machine.

Level: Intermediate

Description: Building distributed systems can be extremely complex, but it doesn’t have to be. gRPC was created as a high performance RPC framework that makes it easy to build client/server applications. Using protocol buffers, you can define both data messages and procedure calls that turn into easy to consume structures and services in Go.

What a student is expected to learn: 

• Students will learn the Protocol Buffer syntax and how to create messages and services with Proto syntax.
• Students will be able to generate robust services with gRPC in Go.
• Students will learn how to create gRPC streams for accepting multiple messages in a service request.

Prerequisites: 

• Familiarity and comfort navigating and basic file manipulation at the command line.
• Familiarity and comfort with a modern code editor, including creating and modifying files and projects.
• 1 to 3 months of daily Go experience.
• At least 6 months of experience with other modern development languages such as Java, C#, Swift, JavaScript, Python, Rust, etc.
• Familiarity with basic programming concepts and structures such as variables, loops, conditionals, etc.

Recommended Preparation: 

• Install and configure an editor for Go.
• Have a functioning Go environment installed with Go 1.16 or later.
• Sign up for a Github account, if you do not already have one.
• Computers should be capable of modern software development, such as access to install and run binaries, install a code editor, etc. 

Level: Intermediate (though Beginners are welcome)

Description: Machine learning and artificial intelligence (ML/AI) applications are increasingly colliding with the systems that we maintain. These applications have a bunch of quirks that make them rather hard to scale, debug, and integrate. ML/AI applications are often written in Python, rely on a variety of large serialized assets (like model binaries), use specialized hardware (like GPUs), and exhibit behavior that is hard to predict. In this workshop, you will learn how to successfully integrate Go applications with common ML/AI components like TensorFlow and PyTorch to create an AI-enabled API for automated question answering. Along the way, you will learn how to appropriately test ML/AI components, collaborate with data science teams, and navigate the weird toolkit used by AI practitioners. 

What a student is expected to learn: In addition to a general understanding of common ML/AI components and their integration with Go applications, you will learn about testing and monitoring methodologies for AI models, common AI inference server infrastructure, and best practices for running AI in production. You will leave the workshop having built a Go API that calls into a state-of-the-art AI model to enable automated question answering.

Prerequisites: You do not need to be a Go or AI expert for this training and beginners are highly encouraged to attend. You do need some exposure to Go and must have at least gone through the Go Tour.

Recommended Preparation: 

• Install and configure an editor for Go.
• Have a functioning Go environment installed with Go 1.16 or later.
• Sign up for a Github account, if you do not already have one.
• Computers should be capable of modern software development, such as access to install and run binaries, install a code editor, etc.

Level: Intermediate (though Beginners are welcome)

Description: Soon after you decide to embrace serverless architectures you realize that there is a need to coordinate all of the components that make up these distributed applications and services. In this training you will stitch together a series of Lambda functions written in the Go programming language to build and orchestrate a fully functional and scalable serverless application while learning how to handle the deployment, logging, metric collection, and distributed tracing that help you effectively adopt the serverless way. 

What a student is expected to learn: In addition to picking up best practices for developing and testing serverless applications in Go, you will learn how to use technologies like AWS SAM CLI, API Gateway, CloudFormation, SQS, DynamoDB, X-Ray, and Step Functions to build, deploy, orchestrate, debug, and manage your serverless applications.

You will leave the workshop having built and orchestrated a multi-component serverless application stack and develop confidence in building your own production-grade serverless applications.

Prerequisites: You do not need to be a Go expert for this training and beginners are highly encouraged to attend. You do need some exposure to Go and must have at least gone through the Go Tour.

Level: Intermediate

Description: This class teaches how to build production-level services in Go with a focus on macro-level engineering decisions. From the beginning you will pair program with the instructor, walking through the design philosophies and guidelines used to engineer the code. With each new feature, you will learn more about the transition from programming to engineering and the points of refactoring required to write production level applications. Throughout the class, Go modules and Kubernetes will be a focus. Everyone will be making better engineering decisions after this class.

 - Kubernetes

 - Initial Service Design

 - Web Framework

 - Middleware

 - Database Support

 - Business Package Design

What a student is expected to learn: This is a trimmed down version of Ultimate Service 3 which takes ~15 hours of actual class time. In this workshop we will have ~6 hours of class time. Bill will do his best to maintain a good pace and focus on the most important things related to the course material.

Prerequisites: A basic understanding of the Go programming language. Students do not have to be expert Go users but, they will get the most from the workshop if they have completed the majority of the Go Tour.

Recommended Preparation: 

• Install and configure an editor for Go.
• Have a functioning Go environment installed with Go 1.16 or later.
• Sign up for a Github account, if you do not already have one.
• Computers should be capable of modern software development, such as access to install and run binaries, install a code editor, etc.

Level: Beginner

Description: This workshop is a gentle introduction to the Go programming language. We will learn the basics of the language using as background the development of a Pac-Man clone that runs on the terminal, with emojis!

We will start from a classic “hello world” type of code and build the game incrementally from there, gradually adding new constructs to our portfolio, including functions, flow control, data structures, tests and so on.

While the project itself is very simple, the game development context is rich enough to allow us to explore even some of the most interesting language features like goroutines, channels and slices. We will also abuse Go’s support for unicode to render the game in the terminal instead of using a graphical library.

All of this while evoking the classic gamer in all of us. ^_^

What a student is expected to learn: At the end of the workshop the student will be able to read and write basic idiomatic Go. A non-exhaustive list of topics covered include: variables, constants, pointers, structs, methods, slices, channels, goroutines, packages, naming conventions, control structures, ANSI escape sequences, errors, JSON parsing, file I/O, flags and tests.

Prerequisites: This is a beginners’ workshop, so you are not expected to know any Go beforehand, although familiarity with at least one programming language is recommended. You should also be comfortable running commands on a terminal window. We strongly recommend you to use either Mac OS X or Linux. If your machine has Windows you may want to install a Linux virtual machine beforehand.

Level: Intermediate

Description: This class teaches how to build production-level services in Go with a focus on macro-level engineering decisions. From the beginning you will pair program with the instructor, walking through the design philosophies and guidelines used to engineer the code. With each new feature, you will learn more about the transition from programming to engineering and the points of refactoring required to write production level applications. Throughout the class, Go modules and Kubernetes will be a focus. Everyone will be making better engineering decisions after this class.

 - Kubernetes

 - Initial Service Design

 - Web Framework

 - Middleware

 - Database Support

 - Business Package Design

What a student is expected to learn: This is a trimmed down version of Ultimate Service 3 which takes ~15 hours of actual class time. In this workshop we will have ~6 hours of class time. Bill will do his best to maintain a good pace and focus on the most important things related to the course material.

Prerequisites: A basic understanding of the Go programming language. Students do not have to be expert Go users but, they will get the most from the workshop if they have completed the majority of the Go Tour.

Recommended Preparation: 

• Install and configure an editor for Go.
• Have a functioning Go environment installed with Go 1.16 or later.
• Sign up for a Github account, if you do not already have one.
• Computers should be capable of modern software development, such as access to install and run binaries, install a code editor, etc.

Level: Intermediate

Description: 

If you write insecure code, it will undo all the effort done by the operations team. This workshop won’t make you a security expert, but it will teach you to avoid common security mistakes and how to write code with security in mind.

What a student is expected to learn: 

In this workshop, we will go over common security threats (OWASP top 10) and talk about the security mindset. We will then review some common security mistakes and how to fix them. We will begin with an application that has several security issues such as injection, XSS, sensitive data exposure, plain bugs, etc., and then we will fix them one by one. By the end of the workshop, you should be better equipped to understand how to write secure code. More importantly, you will walk away from this session thinking about security.

Prerequisites: 

• You should know how to program in Go and have some experience with the command line. 
• Some experience with web APIs and the net/http package is a plus.
• You will need a working Go environment and an IDE such as VSCode or GoLand. 
• You will also need the protoc protocol buffers compiler on your machine.Writing Secure Go Applications

With the upcoming 1.18 Go release, Go will officially support generic functions and types, and will come with a set of new packages providing common generic functionality. Generics add significant expressive power to Go, and with these generic powers come some very concrete responsibilities to keep Go code readable, maintainable, and performing well. After a brief summary of the new features, Go Team members, Ian and Robert, will provide some guidance on where and where not to use generic features, and how to use them for the best possible outcome.

Talk/Attendee Level: All Levels

Have you ever wanted to learn about GitHub Action based in Go? This is the place to start! David will go over the GitHub repo, which provides all the structure needed to build a robust GitHub action using Go based on action-development best practices.

The team will also discuss Cloud-Native Go with KEDA (Kubernetes Event-Driven Autoscaling), as well as KEDA HTTP Addon and Azure Container Apps.

Note: This session is limited to 300 simultaneous attendees; you must be registered for a Virtual Community Ticket to participate.

This session is for anybody who is interested in reducing costs and latency, or debugging problems such as memory leaks, infinite loops, performance regressions, etc.

We'll begin by establishing a simple but useful mental model for the Go runtime and explain how Go differs from other compiled languages. This will serve as a foundation to understand the built-in CPU, Memory, Block, Mutex, and Goroutine Profilers as well as the Runtime Tracer.

Additionally, the presentation will cover eBPF, Linux Perf, and Delve. By the end, attendees should walk away with a solid understanding of the various tools one can use to optimize and debug Go applications.

Talk/Attendee Level: Intermediate

At Capital One we have created a distributed system in Go to process all account data from any modern core or legacy mainframe across the company, with peak traffic of up to 2 million tps and 5Gbps, storing over 20TB on different storage systems across multiple regions in AWS.

We had not established widely adopted Go enterprise service standards, so this required on-the-job library creation, scaling challenges, ramping up an organization of engineers new to Go, designing and redesigning microservice boundaries, all based on hiring Kaylyn as the single Go SME to stand it up. This was a bold decision. Fortunately for this project, it produced great results. In this talk, Kaylyn will cover our biggest challenges and successes to give a practical guide to how any company can transition to writing Go services, from any language. Thanks to Go’s simplicity and scalability, we could linearly scale our teams and exponentially scale our services - and it’s far easier than you might imagine.

Talk/Attendee Level:Intermediate

WebAssembly; you've heard about it, but you're not exactly sure what use it would be in your projects. In this talk Connor breaks down what WebAssembly is, why you'd want to incorporate it into your Go programs, and how to go about doing it. He'll take a look at different languages that compile to WebAssembly, their performance, how they interact with the WebAssembly sandbox and host system, and how to build a Go application that effectively takes advantage of what WebAssembly has to offer. Code samples will be made available on GitHub!

Talk/Attendee Level: Intermediate

Have you ever wanted to learn about GitHub Action based in Go? This is the place to start! David will go over the GitHub repo, which provides all the structure needed to build a robust GitHub action using Go based on action-development best practices.

The team will also discuss Cloud-Native Go with KEDA (Kubernetes Event-Driven Autoscaling), as well as KEDA HTTP Addon and Azure Container Apps.

Note: This session is limited to 300 simultaneous attendees; you must be registered for a Virtual Community Ticket to participate.

You’ve heard of event-driven architectures, but what do they actually look like? Learn what is involved in building an event-driven distributed system and how Go can help you achieve “reliability nirvana”.
The following topics will be covered:
- What is event-driven, why you might want to use it, and how you should go about using it
- What makes Go so well-suited for building distributed systems
- Message systems such as Kafka and RabbitMQ
- How protobuf can help you build a solid platform foundation
- What libraries and patterns to use

 Talk/Attendee Level: Intermediate

What features would you choose to put in a programming language made just for yourself? In 2019, I wrote myself a toy programming language in Go called Ink. Though I didn’t predict it at the time, in the next two years since, I’ve written thousands of lines of Ink programs to build compilers, ray tracers, web apps, and personal dashboards touched by tens of thousands of people. Writing and maintaining my own language also helped me level up as an engineer to understand and appreciate systems underlying my work at a much deeper level. In this session, I want to guide you through how you can (and why you should) build a small programming language of your own!

Talk/Attendee Level: Intermediate

IntroducingAI-driven programming tools is one of the biggest changes that happened to the tech ecosystem as a whole in 2021. While you should not put down your keyboard and go home, you probably do want to get acquainted with this new angle of programming.

In this talk we’ll cover the new tools in the field, discuss whether this will change the way we develop in Go, what the best practices are, and what parts of the language will benefit from this and more.

Talk/Attendee Level: All Levels

How does Go let you seamlessly scale millions of Goroutines atop your system’s threads? Let’s explore the working of the Go scheduler, how it maps Goroutines to OS threads, all while trying to ensure fairness. Let’s also answer the question "What’s up with the hardcoded value of 61 hardcoded in the Go scheduler?" We’ll also learn about the information schedtrace provides, and how one can use it to gain insights into the working of the Go scheduler along with a few runtime APIs to try and “control” the behavior of the Go scheduler.

Talk/Attendee Level: Intermediate

Debuggers can be a powerful tool to use when tracking down a hard to find bug. This talk will include tips for effectively debugging Go code in VS Code, as well as a look into the motivation behind and implementation of the new debug adapter written in Delve. `dlv dap`, the Go implementation of the Debug Adapter Protocol (DAP), provides new features and improvements to the debugging experience in VS Code and can serve as a backend to any DAP-compatible editor.

Talk/Attendee Level: All Levels

Zillow has hundreds of services that are used to connect millions of consumers to real estate partners. Their team has been ramping up usage of Go at Zillow; this tutorial will share how they write maintainable Go services, repeatedly. Doing so allows developers at Zillow to focus on adding business value while making important things like instrumentation, configuration, and resiliency transparent. You will learn how we compose our applications to be transport agnostic, highly testable, and easy to maintain.

Talk/Attendee Level: All Levels

The arrival of quantum computers threatens the security of our online world as we know it, as they enable powerful attacks that break the cryptographic protocols that we use. Fortunately, some alternatives exist that offer resistance against both classical and quantum attacks. We selected Kyber and Dilithium to build a fast and secure library offering implementations in Go of those two post-quantum algorithms. 

In this talk, together I will go through the API; talk about some cool features of our library, for instance, how I enhanced its practical security by deviating from the reference implementations; and finally, discuss its performance and unbox the real costs of deploying post-quantum cryptography.

Talk/Attendee Level : All Levels

Python 2 reached its end-of-life in January 2020 and Khan Academy had a choice of how to move forward with our 10-year-old monolith. We decided on Go and started the long process of porting hundreds of thousands of lines of code. He'll talk about what their system looks like, how their GraphQL-based API (using open source tools like gqlgen and genqlient) allowed them to ship incrementally, and how they planned and tracked this large project.

Talk/Attendee Level: Intermediate

Go’s concurrency mechanism is one of the language's most attractive features. Too much of it can get you in trouble, however. Using nothing but our wits and Go's standard library, we will code an increasingly sophisticated network utility to help us learn how best to take advantage of Go’s concurrency capabilities and how to avoid some of its pitfalls. You'll walk away from this talk with practical skills you can apply to your current and future Go projects.

Talk/Attendee Level: Intermediate