Episode 32
You may have written a simple application server or REST API server in Go. This screencast will level up your net/http knowledge!
We show how to write HTTP servers (using the net/http package) that can do a few advanced tasks.
Episode 31
Learn how to use the Echo framework to write quick and high-quality web services.
Episode 30
Another episode in the Buffalo series! We’re going to talk about how to use the pop library alongside Buffalo to quickly and seamlessly integrate a database into your web application.
Episode 29
We’re continuing the Buffalo series! Lots of web apps have a login button, and yours probably will too. This time, we’re going to learn how to build one so that your users can login with GitHub.
Episode 28
In episode 27, we talked about how to use Go Modules to manage dependencies, but there’s more to the story!
Check out how module servers and Athens fit into the dependencies ecosystem.
Episode 27
Go Modules is a brand new system, but it’s the way we are going to do dependency management in Go, so we all need to be familiar with it!
Episode 26
Let’s take a break from the Buffalo series and talk about a highly requested topic - how to write clients for REST APIs.
Episode 25
We learned about resources and more advanced routing last time in episode 24, so let’s switch gears and focus on how to actually render something to the browser.
Episode 24
We learned about more advanced path routing in episode 22, and today we’re gonna go into Buffalo’s resources feature.
Episode 23
In this episode I’m coming at you from GopherCon Iceland to talk about commonly used packages for Go!
Episode 22
We learned about Buffalo basics in Episode 21, and today we’re going to keep the fun going! We’re gonna talk about taking advantage of more advanced features in the Buffalo request router to build more powerful websites.
Episode 21
How do you build a website with Go? For a while, we all just cobbled something together with the standard library, Gorilla Mux, and so on. We had to figure a lot out on our own. Not anymore! Now we have Buffalo!
Episode 20
Tests are a huge part of your codebase and your workflow includes writing lots
of tests (I hope!) We’ll talk about how to up your testing game using
github.com/stretchr/testify/suite.
Why should you use more than just the standard testing
package? Under what circumstances? What are the benefits? All covered here!
Episode 19
There was a request in #125 that I do a screencast on how to consume json with unknown fields.
This screencast shows how to exactly that! I’ll show how to parse JSON using just the standard library, and also point folks to a package that will help if you don’t want to steal my code (which is totally fine by the way!)
Episode 18
This screencast teaches how to write a command line app in Go. We’ll use the cobra package, which is my go-to for every command line app I’ve written for the last year.
Episode 17
We explore the error interface (https://godoc.org/builtin#error) more closely and explain how and why to create custom error types that you can pass wherever an error is expected.
We also talk about some best practices in exposing and describing your custom types inside of your libraries and packages.
Episode 16
This screencast shows you how to use Go’s Subtests feature. Subtests are new in Go 1.7 and can help you write and organize your code much more easily. They can also help you design and build much more powerful unit and integration tests.
Episode 15
We finish the concurrency series by showing how to solve the “Internet Cafe” problem on Trivial Concurrency Exercises for the Confused Newbie Gopher. The solution we’ll show has a bug, however, and the extended screencast fixes it.
See https://gum.co/gifm-x-15 for more details.
Episode 14
We show how to do use the the html/template package (and its close sibling, text/template). We pay special attention to templating tasks most common to web development like layouts, blocks and partials.
Episode 13
We briefly describe how to use the database/sql package and show example code on how to do CRUD actions against a SQL databases using the flexible database/sql package.
Episode 12
We describe the problem #2 on Trivial Concurrency Exercises for the Confused Newbie Gopher and then present and detail a solution to the problem.
Episode 11
We show how to structure and build a complete JSON API in a Go server. This screencast explains basic structuring patterns and concepts and includes code for a complete, working server that simulates a management system for a platform-as-a-service (PaaS).
Episode 10
We describe the problem #1 on Trivial Concurrency Exercises for the Confused Newbie Gopher and then present and detail a solution to the problem.
Episode 9
We explain what the optional singleton pattern is, how it can make libraries easier to use, and walk through the code for a simple library that uses this pattern.
Episode 8
We explain why you should profile your programs, how to do it, and (briefly) how you can improve your code based on your profile results.
Episode 7
We explain what go get does, and why is isn’t sufficient for dependency management. We also explain what a reproducible build is in Go and why it’s so important, and explain why vendoring achieves reproducible builds. We then introduce Glide and show how we’d vendor the code from episode 6 using the tool.
Episode 6
We show how to write unit tests against HTTP handlers. Using an example API server that proxies the Github API using Google’s go-github client library, we outline and show examples of two methods for testing.
Episode 5
We explain how to write full featured web applications in Go, which cover a wide variety of topics. We focus on database communication, rendering templates, and client-server communication via APIs.
Episode 4
We explain what Websockets are and why they matter
in modern web development. Then, we show how to build a full featured Websocket server
using the gorilla/websocket package.
The example and sample code shows a complete browser-based chat application.
Episode 3
We show how to write more advanced web applications with the gorilla/mux. We walk through example code that implements
a complex REST API and highlights
many of the features of the library.
This screencast expands on concepts in episode 1, but you don’t need to watch that screencast to understand this one.
Episode 2
We show a semi-complex concurrent program with a bug in it, and then use godebug to find, diagnose and fix it.
We also show a few other examples of bugs and show how to find and fix those.
Episode 1
We show how to write a feature-rich RESTful API using only the Go net/http package in the standard library.
Episode 0
Welcome to the first Go In 5 Minutes screencast!
We show how to write code that is extensible and testable and then how to write fast, correct unit tests against it.