Top Related Projects
The Go programming language
A curated list of awesome Go frameworks, libraries and software
Learn Go with test-driven development
A standard library for microservices.
The world’s fastest framework for building websites.
Gin is a high-performance HTTP web framework written in Go. It provides a Martini-like API but with significantly better performance—up to 40 times faster—thanks to httprouter. Gin is designed for building REST APIs, web applications, and microservices.
Quick Overview
The ardanlabs/gotraining repository is a comprehensive resource for learning and mastering the Go programming language. It provides a collection of training materials, including code examples, exercises, and documentation, designed to help developers of all levels improve their Go skills. The repository covers a wide range of topics, from basic syntax to advanced concepts and best practices.
Pros
- Extensive coverage of Go topics, from beginner to advanced levels
- Well-organized content with clear explanations and practical examples
- Regularly updated to reflect the latest Go language features and best practices
- Includes both code examples and exercises for hands-on learning
Cons
- May be overwhelming for absolute beginners due to the vast amount of content
- Some advanced topics might require additional background knowledge
- Not structured as a step-by-step course, which may make it challenging to follow a specific learning path
- Requires self-discipline and motivation to work through the materials independently
Code Examples
Here are a few code examples from the repository:
- Basic Hello World program:
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
This example demonstrates the basic structure of a Go program and how to print to the console.
- Goroutine and channel usage:
package main
import (
"fmt"
"time"
)
func worker(done chan bool) {
fmt.Print("working...")
time.Sleep(time.Second)
fmt.Println("done")
done <- true
}
func main() {
done := make(chan bool, 1)
go worker(done)
<-done
}
This example shows how to use goroutines and channels for concurrent programming in Go.
- Error handling:
package main
import (
"errors"
"fmt"
)
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil
}
func main() {
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println("Result:", result)
}
This example demonstrates error handling in Go using the error interface and multiple return values.
Getting Started
To get started with the ardanlabs/gotraining materials:
-
Clone the repository:
git clone https://github.com/ardanlabs/gotraining.git -
Navigate to the cloned directory:
cd gotraining -
Explore the topics in the
topicsdirectory and start with the ones that interest you or match your skill level. -
Run the code examples and complete the exercises to practice and reinforce your learning.
-
Refer to the README files in each topic directory for additional information and guidance.
Competitor Comparisons
The Go programming language
Pros of go
- Official Go programming language repository, containing the language's source code, standard library, and tools
- Extensive documentation and comprehensive test suite
- Large community of contributors and maintainers
Cons of go
- Steeper learning curve for beginners due to its focus on language internals
- Less structured for learning purposes compared to gotraining
- May be overwhelming for those seeking a guided learning experience
Code comparison
gotraining:
func main() {
fmt.Println("Hello, World!")
}
go:
func main() {
fmt.Println("Hello, World!")
}
Summary
While both repositories are valuable resources for Go developers, they serve different purposes. gotraining is designed as a structured learning resource, offering workshops and examples for those learning Go. On the other hand, go is the official language repository, providing the core language implementation and standard library.
gotraining is more beginner-friendly and focused on teaching, while go is comprehensive but may be overwhelming for newcomers. The code comparison shows that basic syntax remains the same across both repositories, as they both adhere to Go language standards.
Developers looking to learn Go might find gotraining more accessible, while those seeking to contribute to the language itself or explore its internals would benefit more from the go repository.
A curated list of awesome Go frameworks, libraries and software
Pros of awesome-go
- Comprehensive curated list of Go resources, libraries, and tools
- Regularly updated with community contributions
- Easy to navigate and find specific categories of Go-related content
Cons of awesome-go
- Lacks structured learning materials and exercises
- No in-depth explanations or tutorials for Go concepts
- May be overwhelming for beginners due to the sheer volume of information
Code comparison
Not applicable, as awesome-go is a curated list of resources and doesn't contain code examples. gotraining, on the other hand, provides code samples and exercises. For example:
gotraining:
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
awesome-go: No code samples available, as it's a curated list of resources.
Summary
gotraining is a structured training program for learning Go, offering hands-on exercises and code examples. It's ideal for beginners and those seeking a guided learning experience. awesome-go, in contrast, is a comprehensive resource list for Go developers of all levels, providing links to libraries, tools, and projects. While it doesn't offer direct training, it's an invaluable reference for discovering Go-related resources and staying up-to-date with the ecosystem.
Learn Go with test-driven development
Pros of learn-go-with-tests
- Focuses on test-driven development (TDD) approach
- Provides hands-on exercises with immediate feedback
- Covers a wide range of Go concepts through practical examples
Cons of learn-go-with-tests
- May not cover advanced topics as comprehensively as gotraining
- Less structured curriculum compared to gotraining's organized modules
- Might be challenging for absolute beginners without prior programming experience
Code Comparison
learn-go-with-tests example:
func TestHello(t *testing.T) {
got := Hello("Chris")
want := "Hello, Chris"
if got != want {
t.Errorf("got %q want %q", got, want)
}
}
gotraining example:
func BenchmarkSprintf(b *testing.B) {
number := 10
b.ResetTimer()
for i := 0; i < b.N; i++ {
fmt.Sprintf("%d", number)
}
}
Both repositories offer valuable resources for learning Go, with learn-go-with-tests emphasizing TDD and practical exercises, while gotraining provides a more structured and comprehensive curriculum. The choice between them depends on the learner's preferred learning style and prior experience with programming and Go.
A standard library for microservices.
Pros of kit
- Comprehensive microservices toolkit with ready-to-use components
- Strong focus on observability and instrumentation
- Active community and regular updates
Cons of kit
- Steeper learning curve for beginners
- More opinionated architecture, potentially less flexible
- Heavier dependency footprint
Code Comparison
gotraining:
func main() {
fmt.Println("Hello, World!")
}
kit:
func main() {
svc := myservice.New(logger, db)
endpoints := myendpoints.New(svc, logger)
httpHandler := httptransport.NewServer(endpoints.Endpoint, decodeRequest, encodeResponse)
http.ListenAndServe(":8080", httpHandler)
}
Summary
gotraining is primarily an educational resource for learning Go, offering a structured curriculum and hands-on exercises. It's ideal for beginners and those looking to improve their Go skills.
kit, on the other hand, is a production-ready toolkit for building microservices in Go. It provides a set of packages and best practices for creating robust, scalable services with features like service discovery, load balancing, and metrics.
While gotraining focuses on teaching Go fundamentals, kit assumes a certain level of Go proficiency and emphasizes microservice architecture patterns. The choice between them depends on whether you're looking to learn Go or build production microservices.
The world’s fastest framework for building websites.
Pros of Hugo
- Mature, widely-used static site generator with extensive documentation
- Large community and ecosystem of themes and plugins
- Faster build times for large sites compared to other static site generators
Cons of Hugo
- Steeper learning curve for non-technical users
- Less flexibility for custom Go code integration compared to a training repository
- Limited to static site generation, not a general-purpose Go learning resource
Code Comparison
Hugo (config.toml):
baseURL = "https://example.org/"
languageCode = "en-us"
title = "My Hugo Site"
theme = "ananke"
Gotraining (example Go code):
package main
import "fmt"
func main() {
fmt.Println("Hello, Go!")
}
Hugo is a powerful static site generator, while Gotraining is a comprehensive Go programming course. Hugo focuses on website creation, offering speed and flexibility for content-heavy sites. Gotraining provides in-depth Go language instruction, covering various aspects of Go development.
Hugo is better suited for those looking to build static websites quickly, while Gotraining is ideal for developers wanting to learn Go programming from the ground up. The choice between the two depends on the user's specific needs: website creation or Go language proficiency.
Gin is a high-performance HTTP web framework written in Go. It provides a Martini-like API but with significantly better performance—up to 40 times faster—thanks to httprouter. Gin is designed for building REST APIs, web applications, and microservices.
Pros of Gin
- Lightweight and fast web framework with excellent performance
- Extensive middleware support and easy-to-use API
- Large community and ecosystem with many third-party plugins
Cons of Gin
- Focused solely on web development, not a comprehensive Go training resource
- Less emphasis on best practices and idiomatic Go code
- Limited coverage of advanced Go concepts and patterns
Code Comparison
Gin (HTTP routing):
r := gin.Default()
r.GET("/ping", func(c *gin.Context) {
c.JSON(200, gin.H{"message": "pong"})
})
r.Run()
Gotraining (HTTP server):
http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(map[string]string{"message": "pong"})
})
http.ListenAndServe(":8080", nil)
Summary
Gin is a popular web framework for Go, offering high performance and ease of use. Gotraining, on the other hand, is a comprehensive Go training resource covering various aspects of the language and best practices. While Gin excels in web development scenarios, Gotraining provides a broader educational experience for Go developers. The choice between the two depends on whether you're looking for a web framework or a learning resource for Go programming.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Go Training
Review our different courses and material
Copyright 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, Ardan Labs
hello@ardanlabs.com
Learn More
Reach out about corporate training events, open enrollment live training sessions, and on-demand learning options.
Ardan Labs (www.ardanlabs.com)
hello@ardanlabs.com
To attend any of our high-performance tranings check out this link:
https://www.ardanlabs.com/training
Index
- Purchase Video
- Experience
- Teachers
- More About Go
- Minimal Qualified Student
- Important Reading
- Before You Come To Class
- Twitter Reactions
- Testimonials
Purchase Video / Book
The entire training class has been recorded to be made available to those who can't have the class taught at their company or who can't attend a conference. This is the entire class material.
There is a book for all of the material in the class.
Our Experience
We have taught Go to thousands of developers all around the world since 2014. There is no other company that has been doing it longer and our material has proven to help jump-start developers 6 to 12 months ahead of their knowledge of Go. We know what knowledge developers need in order to be productive and efficient when writing software in Go.
Our classes are perfect for intermediate-level developers who have at least a few months to years of experience writing code in Go. Our classes provide a very deep knowledge of the programming language with a big push on language mechanics, design philosophies and guidelines. We focus on teaching how to write code with a priority on consistency, integrity, readability and simplicity. We cover a lot about âif performance mattersâ with a focus on mechanical sympathy, data oriented design, decoupling and writing/debugging production software.
Our Teachers
William Kennedy (@goinggodotnet)
William Kennedy is a managing partner at Ardan Labs in Miami, Florida. Ardan Labs is a high-performance development and training firm working with startups and fortune 500 companies. He is also a co-author of the book Go in Action, the author of the blog GoingGo.Net, and a founding member of GoBridge which is working to increase Go adoption through diversity.
Video Training
Ultimate Go Video
Ardan Labs YouTube Channel
Blog
Going Go
Writing
Running MongoDB Queries Concurrently With Go
Go In Action
Articles
IT World Canada
Video
GopherCon USA (2025): Goâs Trace Tooling and Concurrency
GopherCon UK (2025) - Building a coding agent from scratch
GopherCon UK (2025) - K8s CPU Limits Deconstructed - Bill Kennedy
Golang Charlotte (2024) - Domain Driven, Data Oriented Architecture
GopherCon SG (2023) - K8s CPU Limits and Go
P99 Talk (2022) - Evaluating Performance In Go
GopherCon Europe (2022) - Practical Memory Profiling
Dgrpah Day (2021) - Getting Started With Dgraph and GraphQL
GDN Event #1 (2021) - GoBridge Needs Your Help
Training Within The Go Community (2019)
GopherCon Australia (2019) - Modules
Golab (2019) - You Want To Build a Web Service?
GopherCon Singapore (2019) - Garbage Collection Semantics
GopherCon India (2019) - Channel Semantics
GoWayFest Minsk (2018) - Profiling Web Apps
GopherCon Singapore (2018) - Optimizing For Correctness
GopherCon India (2018) - What is the Legacy You Are Leaving Behind
Code::Dive (2017) - Optimizing For Correctness
Code::Dive (2017) - Go: Concurrency Design
dotGo (2017) - Behavior Of Channels
GopherCon Singapore (2017) - Escape Analysis
Capital Go (2017) - Concurrency Design
GopherCon India (2017) - Package Oriented Design
GopherCon India (2015) - Go In Action
GolangUK (2016) - Dependency Management
GothamGo (2015) - Error Handling in Go
GopherCon (2014) - Building an analytics engine
Golang Charlotte (2023) - Domain Driven, Data Oriented Architecture with Bill Kennedy
Prague Meetup (2021) - Go Module Engineering Decisions
Practical Understanding Of Scheduler Semantics (2021)
Go Generics Draft Proposal (2020)
Hack Potsdam (2017) - Tech Talk with William Kennedy
Chicago Meetup (2016) - An Evening
Vancouver Meetup (2016) - Go Talk & Ask Me Anything With William Kennedy
Vancouver Meetup (2015) - Compiler Optimizations in Go
Bangalore Meetup (2015) - OOP in Go
GoSF Meetup - The Nature of Constants in Go
London Meetup - Mechanical Sympathy
Vancouver Meetup - Decoupling From Change
Podcasts
Ardan Labs Podcast: On Going Series
Mangtas Nation: A Golang Deep Dive with Bill Kennedy
Coding with Holger: Go with Bill Kennedy
Craft of Code: From Programming to Teaching Code with Bill Kennedy
GoTime: Design Philosophy
GoTime: Learning and Teaching Go
GoTime: Bill Kennedy on Mechanical Sympathy
GoTime: Discussing Imposter Syndrome
HelloTechPros: Your Tech Interviews are Scaring Away Brilliant People
HelloTechPros: The 4 Cornerstones of Writing Software
More About Go
Go is an open source programming language that makes it easy to build simple, reliable, and efficient software. Although it borrows ideas from existing languages, it has a unique and simple nature that make Go programs different in character from programs written in other languages. It balances the capabilities of a low-level systems language with some high-level features you see in modern languages today. This creates a programming environment that allows you to be incredibly productive, performant and fully in control; in Go, you can write less code and do so much more.
Go is the fusion of performance and productivity wrapped in a language that software developers can learn, use and understand. Go is not C, yet we have many of the benefits of C with the benefits of higher level programming languages.
The Ecosystem of the Go Programming Language - Henrique Vicente
The Why of Go - Carmen Andoh
Go Ten Years and Climbing - Rob Pike
The eigenvector of "Why we moved from language X to language Y" - Erik Bernhardsson
Learn More - Go Team
Simplicity is Complicated - Rob Pike
Getting Started In Go - Aarti Parikh
Minimal Qualified Student
The material has been designed to be taught in a classroom environment. The code is well commented but missing some of the contextual concepts and ideas that will be covered in class. Students with the following minimal background will get the most out of the class.
- Studied CS in school or has a minimum of two years of experience programming full time professionally.
- Familiar with structural and object oriented programming styles.
- Has worked with arrays, lists, queues and stacks.
- Understands processes, threads and synchronization at a high level.
- Operating Systems
- Has worked with a command shell.
- Knows how to maneuver around the file system.
- Understands what environment variables are.
Important Reading
Please check out this page of important reading. You will find articles and videos around mechanical sympathy, data-oriented design, Go runtime and optimizations and articles about the history of computing.
Before You Come To Class
The following is a set of tasks that can be done prior to showing up for class. We will also do this in class if anyone has not completed it. However, the more attendees that complete this ahead of time the more time we have to cover additional training material.
Prep Work
Watch This
Prepare You Mind
Reading Material
http://go.dev/
https://www.ardanlabs.com/blog/
Exercises
https://tour.golang.org/welcome/1
https://gophercises.com/
Books
https://www.manning.com/books/go-in-action
https://bitfieldconsulting.com/books/fundamentals
Joining the Go Slack Community
We use a slack channel to share links, code, and examples during the training. This is free. This is also the same slack community you will use after training to ask for help and interact with may Go experts around the world in the community.
- Using the following link, fill out your name and email address: https://invite.slack.gobridge.org/
- Check your email, and follow the link to the slack application.
Installing Go
Local Installation
https://www.ardanlabs.com/blog/2016/05/installing-go-and-your-workspace.html
Editors
Visual Studio Code
https://code.visualstudio.com/Updates
https://github.com/microsoft/vscode-go
VIM
http://www.vim.org/download.php
http://farazdagi.com/blog/2015/vim-as-golang-ide/
Goland
https://www.jetbrains.com/go/
Installing the Training Material
While many of the examples can be done using the online playground (http://play.golang.org), some may find it easier to complete them with their local editor. To do so, you will want to load the training material locally to your machine. From a command prompt, issue the following commands:
mkdir -p $(go env GOPATH)/src/github.com/ardanlabs && cd $_
git clone https://github.com/ardanlabs/gotraining.git
NOTE: This assumes you have Git installed. If you donât, you can find the installation instructions here: https://git-scm.com/
Jessie Frazelle (@frazelledazzell)
"@goinggodotnet you were amazing!!! So enthusiastic!!! Thanks for doing this for everyone!"
Kelsey Hightower (â@kelseyhightower)
"Day 1 of the [Ultimate] Go workshop was outstanding! Big shoutout to @intel, @golangbridge, and @goinggodotnet for bringing this to Portland."
Katrina Owen (@kytrinyx)
"OH: "You thought you knew Go..." (You do Go? You want to do Go?) You should take this workshop. Seriously.) "
Ian Molee (@ianfoo) "If you're at @GopherCon, get yourself to a session with @goinggodotnet. Superb! Pretty sure his pic appears with the definition of "dynamo.""
Matt Oswalt (@Mierdin)
"Should be mentioned that though I am no expert, I have been using Go for about a year - and this meetup is kicking my ass."
Testimonials
Paul Yeoh
_"Todayâs workshop was just mind blowing! You kept us all on the edge all day long - it was the most exhilarating all day workshop I have attended, period. The content was inspiring, moving - caused me to think deeply and gave me a lot of meat to chew on about what it is we are really doing as programmers, what an awesome day!
And most of all, I just got such a kick out of the energy which you were putting out - larger than life, it felt like you were turned up to 200%. I really took a lot from it at many levels. Thank you!!"_
Ana-Maria Lazar, Software Engineer at Sainsbury's
"Intensive crash course in Go that literally takes you to a whole new level. Not only Bill provides lots of examples and exercises to familiarize yourself faster with the language but there is also a lot of information that can be applied to other languages as well. Perfect combination!"
Susan Dady, Software Engineer - GE Digital
"Rarely will you come across a course as worthwhile as this one. I learned many things relevant and useful in my daily work and William's energy kept me engaged. I came back to work excited to get coding in Go."
Richard Stanley, Software Engineer - GE Digital
"Not only does Bill deeply understands the technical details of Go, he also can explain them in an effective, enthusiastic manner that helped me retain somewhat dry material. His passion for the language and its capabilities are obvious through out his training."
Shalab Goel, Ph.D.
"It was a pleasure taking this course â learning lot of "dry" stuff in such animated and enthusiastic environment. The exercises were spot on for building what you called as "memory muscle. I have good amount of background in conventional multithreaded and distributed environments, but I have not put that knowledge to use more recently; so it was good refresher from that point of view as well. From Yuck to completely Wow-ed is how I will like to describe my respect for Go within three days. I knew nothing about GO before the course."
Geoff Clitheroe (@gclitheroe)
"Your training is awesome! Myself and three colleagues recently caught variations of the training at GopherCon and OSCON. We all thought the Bootcamp was the best thing at any of these conferences (and I went to both). Awesome work to Bill for presenting and anyone involved in developing the training. I really liked the structure, emphasis on deeper understanding, me doing a small number of examples to emphasize this, and general content. Night and day to other training which is to often just watching someone else live code. Great work."
ACL Services (@ACLServices)
"I'd just like to thank you again for just a phenomenal training session. The feedback from everyone was overwhelmingly positive. You probably could tell first hand that there were skeptics at first, but you've turned many into golang converts and we are really excited in growing golang adoption internally."
Joshua Shuster (@naysaier)
"I would consider Ardan Studio's 3 day course to be invaluable. Bill and his staff, being some of the foremost authorities in the Go language, were able to make many of the complex go topics understandable. Covering everything from memory management, all the way up to building concurrency programs and web API's. It has given me the knowledge to write idiomatic Go, and make the best use of its features. I would highly their courses to anyone new to Go, or to anyone wanting to widen their existing knowledge."
Neeru Dwivedi
"I attended the one day workshop by Bill Kennedy from Ardan Labs. I was in for a surprise as before the workshop I was concerned whether I would understand concepts and whether I would be able to follow along. Bill has this wonderful way of explaining concepts and his knowledge on the concepts is so good that, I didn't feel that I was learning something new & complicated. The Go Workshop got me started on the Go language. This workshop is perfect for beginners and anyone who wants to learn more about Go. I highly recommend this."
Todd Rafferty (@webrat)
"I highly recommend William Kennedy / Ardan Lab for Go Training. William is extremely passionate about the Go language and his energy feeds into his training. Very professional, very informative. My favorite section of his training, if I had to pick, was the segment on MultiWriters. I highly recommend a 3 day course, over a 2 day course. Even after the classes were over, William was always responsive with additional questions via various social media channels."
Georgi Knox (@GeorgiCodes)
"The Intro to Go Workshop enabled me to come into class with very little knowledge of Go and leave having a firm grasp of the key concepts of the language. Each topic was followed up with hands-on coding problems which helped to solidify what I was learning. My teacher Bill was not only approachable, but very excited about the language and his enthusiasm was contagious. I enjoyed that we talked about some of the lower level implementation details of Go which was something that I had found lacking from some books on the language. Overall I would highly recommend this workshop to anyone looking to learn Go quickly and effectively."
All material is licensed under the Apache License Version 2.0, January 2004.
Top Related Projects
The Go programming language
A curated list of awesome Go frameworks, libraries and software
Learn Go with test-driven development
A standard library for microservices.
The world’s fastest framework for building websites.
Gin is a high-performance HTTP web framework written in Go. It provides a Martini-like API but with significantly better performance—up to 40 times faster—thanks to httprouter. Gin is designed for building REST APIs, web applications, and microservices.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot