Masters Style Go Courses
After training for over four years, and recently enrolling in my own Masters degree program, I've married both of my passions and I'm excited to announce our new Masters Style Go Courses!
Table Driven Testing In Parallel
Table driven testing is not a unique concept to the Go programming language. However, there are some great features that make table driven testing in Go faster and more reusable. This article will cover how to get the most out of table driven testing with Go (golang).
Exploring "io/fs" to Improve Test Performance and Testability
The most anticipated feature of Go
1.16 is the addition to the Go tooling, and standard library, that allow for embedding static content into binaries. While it is tempting to start playing with this new toy right away, it is important to understand how it works first. In this article we are going to take a look at the new
io/fs package introduced in Go
1.16 to support embedding.
Where and When to use Iota in Go
Iota is a useful concept for creating incrementing constants in Go. However, there are several areas where iota may not be appropriate to use. This article will cover several different ways in which you can use iota, and tips on where to be cautious with it's use.
Leveraging the Go Type System
If you haven't worked in a typed language before, it may not be obvious at first the power that it brings. This article will show you how to leverage the type system to make your code easier to use and more reusable.
Embracing the Go Type System
Go is a typed language, but most Go developers don't truly embrace it. This short article talks about tips and tricks to write more robust code using custom types in Go.
What's in a name?
The art of writing software is the act of communication. You might feel that this is a private conversation about your code with a persnickety compiler, but the audience for software is much larger. It’s the people who use your libraries and your APIs, the folks who work with you maintaining the codebase, and it's you, in the future, searching for clues about why you wrote what you wrote the way you wrote it. This talk is all about naming. It’s about the names we give to things in our programs and how those decisions can affect the maintainability of the software we write.
What's new in Go 1.14: Test Cleanup
The process of writing a unit test usually follows a certain set of steps. First, we set up dependencies of the unit under test. Next, we execute the unit of logic under test. We then compare the results of that execution to our expectations. Finally, we tear down any dependencies and restore the environment to the state we found it so as not to affect other unit tests. In Go 1.14, the
testing package now includes a method,
testing.(*T).Cleanup, which aims to make creating and cleaning up dependencies of tests easier.
Converting a Static Site to Buffalo
I recently had a friend come to me and mention that their website I created for them years ago needed some updating. After looking at it, it was clear it was time for an update. This article will walk through the design decisions and technical challenges that I needed to address in bringing their site up to some modern standards.
Don’t Commit Improperly Formatted Go (golang) Code
This article will outline how in just a few easy steps using
git hooks how to ensure you never commit improperly formatted code.