Gopher Academy Blog

Important Conference Announcement

Fri, 27 May 2022 11:00:00 -0500

You may have noticed that the team at Gopher Academy has been unusually quiet lately. In April, we contacted the Walt Disney World Swan and Dolphin Resort to discuss the cancellation of our conference at their property.

GoVirCon is back

Fri, 17 Sep 2021 12:15:00 +0600

With cases of COVID-19 continuing to rise throughout the US due to the Delta variant, we at Gopher Academy have made the bittersweet decision to bring GoVirCon back.

Storytelling On Stage: Proposal Writing For Procrastinators

Mon, 19 Apr 2021 13:00:00 +0000

Crafting a GopherCon Proposal The Call for Proposals for GopherCon 2021 is closing in less than a week for GopherCon 2021. If you’re reading this, I’m assuming you’re thinking about submitting a proposal.

Storytelling On Stage: Advice

Mon, 12 Apr 2021 13:00:00 +0000

Crafting a GopherCon Proposal The Call for Proposals for GopherCon 2021 is open! If you’re reading this I’m assuming you’re thinking about submitting a proposal.

Storytelling On Stage: Storytelling

Mon, 05 Apr 2021 13:00:00 +0000

Crafting a GopherCon Proposal The Call for Proposals for GopherCon 2021 is now open! If you’re reading this, I’m assuming you’re thinking about submitting a proposal.

Storytelling On Stage: The Basics

Mon, 29 Mar 2021 13:00:00 +0000

Crafting a GopherCon Proposal The Call for Proposals for GopherCon 2021 opens April 5th, and if you’re reading this I’m going to assume you’re thinking about submitting a talk for GopherCon 2021, however you may be struggling with how to start.

GopherCon 2020 Agenda

Thu, 17 Sep 2020 00:13:34 +0600

#GoVirCon Schedule Announced We’re really excited to announce the schedule for our virtual presentation of GopherCon 2020! Our official programming starts on Monday, November 9th and Tuesday, November 10th with our trademark pre-conference workshops.

GopherCon 2020 Online

Thu, 09 Jul 2020 13:13:34 +0600

#GopherCon is now #GoVirCon! With increasing cases of coronavirus in the US, travel bans and restrictions holding strong likely through the end of the year, and Gopher Academy’s increasing concern regarding the health and well-being of our community members, at the end of June we made a confident decision to cancel the in-person conference.

GopherCon 2020 Update

Thu, 19 Mar 2020 13:13:34 +0600

It’s been a few weeks since our first release about GopherCon and COVID-19, so we wanted to share an update. You all are the backbone of this conference and so important to us!

GopherCon 2020 COVID-19 Response

Mon, 02 Mar 2020 13:13:34 +0600

Many in the community are facing concerns about COVID-19, the disease caused by the newly discovered coronavirus [1]. We at Gopher Academy are following the status of COVID-19 carefully in preparation for the June conference.

HTML, CSS and Go, Together at Long Last: Vugu Premise and Example

Wed, 25 Dec 2019 00:00:00 +0000

Huh, what’s a Vugu? Vugu is a Go library that makes it easy to write HTML markup and Go code which is compiled and run in the browser using WebAssembly.

Some Thoughts on Library Design

Wed, 18 Dec 2019 06:40:42 +0000

As programmers we use libraries a lot. But library design is hard. In this article, I will walk through some considerations in designing a library.

API Clients for Humans

Sat, 14 Dec 2019 00:00:00 +0000

Most developers, at one point or another, have either built a web API or have been a consumer of one. An API client is a package that provides a set of tools that can be used to develop software that consumes a specific API.

Navigating the uncharted waters of SSL/TLS certificates and gRPC with Go

Thu, 12 Dec 2019 00:00:00 +0000

There are different ways to establishing a secure TLS connection with Go and gRPC. Contrary to popular belief, you don’t need to manually provide the Server certificate to your gRPC client in order to encrypt the connection.

Control packet flow with TCP_NODELAY in Go

Wed, 11 Dec 2019 00:00:00 +0000

Writing web services requires a lot of effort and thinking to make them robust and performant. There’s a wide range of areas to look in order to improve the performance of our service.

Test Driven Advent of Code

Tue, 10 Dec 2019 00:00:00 +0000

By now most of you have probably heard of Advent of Code. If not, go check it out. I’ll give you a few moments…

Benchmark Surprises

Mon, 09 Dec 2019 00:00:00 +0000

I love a good mystery. If you really want my undivided attention, present me with a program which does a thing, and also a proof that it can’t possibly do that thing.

Building a global services network using Go, QUIC and Micro

Sun, 08 Dec 2019 00:00:00 +0000

Over the past 6 months we at Micro have been hard at work developing a global service network to build, share and collaborate on microservices.

Como construir sitios web con HUGO

Fri, 06 Dec 2019 10:07:34 +0900

Esta publicación tiene como objetivo enseñar a como construir sitios web utilizando HUGO y como subirlo a un hosting. Hugo es un generador de sitios web estáticos construidos con el lenguaje GO, fue creado en el año 2013.

Fun With Flags

Fri, 06 Dec 2019 00:00:00 +0000

In a previous article we discussed why command line applications are important and talked about few guidelines. In this article we’ll see how we can use the built-in flag package to write command line applications.

Safe use of unsafe.Pointer

Thu, 05 Dec 2019 00:00:00 +0000

Package unsafe provides an escape hatch from Go’s type system, enabling interactions with low-level and system call APIs, in a manner similar to C programs.

Contribute Beyond Code: Open Source for Everyone

Wed, 04 Dec 2019 00:00:00 +0000

Developers are often encouraged to contribute to open source. If you don’t consider yourself a developer, it can feel daunting to start on the journey to contributing.

Directional Channels in Go

Tue, 03 Dec 2019 00:00:00 +0000

Go’s channels provide a primitive for typed, synchronous message passing. Combined with goroutines, they form the backbone of Go’s CSP-inspired concurrency model. They’re simple and expressive, but they can be difficult to use properly, especially if you need to control who can read from them or write to them.

Writing Friendly Command Line Applications

Mon, 02 Dec 2019 00:00:00 +0000

Let me tell you a story… In 1986 Knuth wrote a program to demonstrate literate programming. The task was to read a file of text, determine the n most frequently used words, and print out a sorted list of those words along with their frequencies.

Go Advent Introduction

Sun, 01 Dec 2019 05:26:58 -0500

Our tradition at Gopher Academy is to host an Advent Calendar of blog posts contributed by the community each December. I’m excited to kick off the 2019 series with this introduction!

Reactive planning and reconciliation in Go

Tue, 19 Nov 2019 15:07:34 +0900

I wrote a quick introduction about why I think reactive planning is a cloud native pattern and I published an article about control theory, but I have just scratched the surface of this topic obviously.

Integration test made easy with testcontainers

Sat, 19 Jan 2019 15:07:34 +0900

There are a lot of information in the title I know, but I am not good enough to make it simple. Back in the days, I tried to make some contribution to OpenZipkin an open source tracing infrastructure in Java.

Personal Photo Management using Go and TensorFlow

Thu, 27 Dec 2018 00:00:00 +0000

We love taking photos. Privacy concerns - and the wish to properly archive them for the next generation - brought us to the conclusion that existing cloud solutions are not the right tool to keep them organized.

Avoiding high GC overhead with large heaps

Tue, 25 Dec 2018 08:00:00 +0000

The Go Garbage Collector (GC) works exceptionally well when the amount of memory allocated is relatively small, but with larger heap sizes the GC can end up using considerable amounts of CPU.

Using Go in Devops

Mon, 24 Dec 2018 00:00:00 +0000

== Using Go for DevOps == This post is aiming to provide a new angle on using Go. Don’t expect code snippets or learning a new thing, but rather be open for a new perspective, and share this with your favorite SysOps/DevOps/Observability Engineers who are considering new solutions.

Computing and plotting π with Gonum and a zest of Monte Carlo

Sun, 23 Dec 2018 00:00:01 +0000

Today we will see how we can compute π with a technique called Monte Carlo. Wikipedia, the ultimate source of truth in the (known) universe has this to say about Monte Carlo:

GPIOs and Go

Sat, 22 Dec 2018 00:00:00 +0000

Go Advent, Dec. 22, 2018 Recently, I decided that I needed a small heads up display for import things I kept forgetting, like the time until an event started or number of unread emails in my inbox.

Members, Methods, and Interfaces

Fri, 21 Dec 2018 00:00:00 +0000

Opaque Datatypes Considered Awesome I am periodically reminded that many people don’t realize that C actually allows the creation of opaque data types. This is a possibly-surprising side effect of the option of never completing a type.

Introducing Glot the plotting library for Golang

Thu, 20 Dec 2018 00:00:00 +0000

Go is an open source programming language that makes it easy to build simple, reliable, and efficient software. It provides an expressive syntax with its lightweight type system and comes with concurrency as a built-in feature at the language level.

LLVM IR and Go

Wed, 19 Dec 2018 08:00:00 +0000

In this post, we’ll look at how to build Go programs – such as compilers and static analysis tools – that interact with the LLVM compiler framework using the LLVM IR assembly language.

Go and Apache Arrow: building blocks for data science

Tue, 18 Dec 2018 00:00:00 +0000

Today we will see how Apache Arrow could be useful for data science, or – really – a lot of analysis workloads. Lingua franca In Data Science and in many scientific fields, the lingua franca is Python.

Apache Beam and Google Dataflow in Go

Mon, 17 Dec 2018 00:00:00 +0000

Overview Apache Beam (batch and stream) is a powerful tool for handling embarrassingly parallel workloads. It is a evolution of Google’s Flume, which provides batch and streaming data processing based on the MapReduce concepts.

The Relationship Between Interfaces and Reflection

Sun, 16 Dec 2018 00:00:00 +0000

Interfaces are one of the fundamental tools for abstraction in Go. Interfaces store type information when assigned a value. Reflection is a method of examining type and value information at runtime.

Debugging with Mozilla rr project and GoLand

Sat, 15 Dec 2018 00:00:00 +0000

Debuggers. Traditionally they are used to find complex bugs and reason about how they happen. But what if you cannot explain why some changes happen between steps?

Exploring byte parsing APIs in Go

Fri, 14 Dec 2018 00:00:00 +0000

Several years ago, I began exploring Linux’s Netlink inter-process communication interface. Netlink is used for retrieving information from the Linux kernel, and in order to cross the kernel boundary, information is typically packed into Netlink attributes.

Bringing Sanity to your Dependencies with Go Modules and Athens

Thu, 13 Dec 2018 00:00:00 +0000

As many of us know, Go version 1.11 introduced Go Modules, a brand new dependency management system. A Little Bit About Modules Before 1.11, our dependencies were a collection of Go packages with a single version number attached to all of them.

gpython: a Python interpreter written in Go "batteries not included"

Wed, 12 Dec 2018 00:00:00 +0000

Gpython is a Python 3.4 interpreter written in Go. This is the story of how it came to be, how it works and where it is going.

Improve Your Breadmaking Skills with Go and Open-Source Monitoring

Tue, 11 Dec 2018 00:00:00 +0000

I have many different interests, including baking, open-source software, and more recently, systems monitoring and learning Go. As a way for me to expand my practical knowledge on each item, I devised a fun little project that leverages sensors, Raspberry Pis, and Prometheus to improve my sourdough breadmaking process.

Creating WebGL apps with Go

Mon, 10 Dec 2018 00:00:00 +0000

TL;DR In this article I’ll share my experience building an interactive 3D WebGL-based application for peer-to-peer messaging protocol simulation without writing any single line in JS.

Building a CI/CD Bot with Slack and Kubernetes.

Sun, 09 Dec 2018 00:00:00 +0000

This article is about an experiment at Africa’s Talking on using Slack to manage our deployment process. Like many companies, we use Kubernetes to manage our deployments, and Slack for internal communications.

A Dive Into the `fmt` Package

Sat, 08 Dec 2018 00:00:00 +0000

We usually use the fmt package without giving it much thought. A fmt.Printf here, a fmt.Sprintf there and on we go. However, if you’ll take a closer look, you’ll be able to get much more out of it.

Go and WebAssembly: running Go programs in your browser

Fri, 07 Dec 2018 00:00:00 +0000

For a long time, Javascript was the lingua franca amongst web developers. If you wanted to write a stable, mature web app, writing in javascript was pretty much the only way to go.

On the tension between generic code and special cases

Thu, 06 Dec 2018 00:00:00 +0000

The io.Reader and io.Writer interfaces appear in practically all Go programs, and represent the fundamental building blocks for dealing with streams of data. An important feature of Go is that the abstractions around objects such as sockets, files, or in-memory buffers are all expressed in terms of these interfaces.

How to Send and Receive SMS: Implementing a GSM Protocol in Go

Wed, 05 Dec 2018 00:00:00 +0000

When developers add an SMS component in their app either for verification or notification purposes, they usually do it via RESTful API like the ones provided by Twilio.

Golang and local datastores - fast and flexible data storage

Tue, 04 Dec 2018 00:00:00 +0000

Local datastores may not be a fit if you are building a web application that may have more than a single instance and a somewhat rich data schema.

Best Practices for Using Mage To Build Your Project

Mon, 03 Dec 2018 00:00:00 +0000

On my team at Mattel, we have a magefile for every Go project (and we have several Go projects). Our use of mage has grown with the team and the projects, and it has been a big help keeping our dev practices uniform and shareable.

Postmortem debugging Go services with Delve

Sun, 02 Dec 2018 00:00:00 +0000

One day, several instances of one of our production services stopped accepting incoming traffic. HTTP requests successfully went through the load balancer reaching the instance and just hanged.

Splitting Data with Content-Defined Chunking

Sat, 01 Dec 2018 00:00:00 +0000

In this post you’ll learn what Content-Defined Chunking (CDC) is and how you can use it to split large data into smaller blocks in a deterministic way.

New Go Community Code of Conduct

Wed, 23 May 2018 12:30:00 +0000

In November 2015, Google introduced the Go Code of Conduct (CoC) and as the leading Go language conference, it was important for us to set an example by publishing and enforcing this Code of Conduct to safeguard the dignity and well-being of all who work in the Go Community.

Simple messaging framework using Go TCP server and Kafka

Sun, 31 Dec 2017 00:00:00 +0000

I needed to create a simple framework to provide my endpoint devices ( doesn’t matter which platform they run on ) the option to send and receive messages from my backend.

Go 1.10

Sat, 30 Dec 2017 00:00:00 +0000

Table of contents Language changes Operating Systems support Tooling Environment Variables go build go install go test gofmt go fix pprof Runtime CGO support Debugging Assembly support Packages Closing notes Introduction Go 1.

Create a Slack bot with golang

Fri, 29 Dec 2017 00:06:00 +0000

Create a Slack bot with golang Introduction In this post we’ll look at how to set up a quick Slack bot that receives messages (either direct or from channel) and replies to the user.

TensorFlow and Go

Thu, 28 Dec 2017 20:00:00 +0000

This year I helped organize several online security challenges, one of which is Blacklight. Among the things I was asked to do, was creating a POC for a specific challenge, to prove that it’s possible to solve in a reasonable time.

Using Go Templates

Wed, 27 Dec 2017 00:00:00 -0800

Go templates are a powerful method to customize output however you want, whether you’re creating a web page, sending an e-mail, working with Buffalo, Go-Hugo, or just using some CLI such as kubectl.

Method Closures: You Can't Do That In Go

Tue, 26 Dec 2017 00:00:01 +0000

Neugram is a scripting language that sticks very close to Go. Go statements are Neugram statements, you can import Go packages, scripts can be compiled to Go programs, and types look just like the equivalent Go types at run time (which means packages built on reflection, like fmt, work as expected).

Make Your Build Better With Mage

Mon, 25 Dec 2017 00:00:00 +0000

Many Go projects can be built using only Go’s wonderful built-in tooling. However, for many projects, these commands may not sufficient. Maybe you want to use ldflags during the build to embed the commit hash in the binary.

Managing goroutine lifecycles with run.Group

Sun, 24 Dec 2017 00:34:34 +0000

I stumbled over this idiom for managing goroutine lifecycles when I was writing OK Log. Since then I’ve found uses for it in nearly every program I’ve written.

Go execution tracer

Sat, 23 Dec 2017 20:00:00 +0000

Introduction Ever wondered how are your goroutines being scheduled by the go runtime? Ever tried to understand why adding concurrency to your program has not given it better performance?

Building medical reports in Go

Fri, 22 Dec 2017 20:00:00 +0000

This article is about how we at Mendelics changed our report system from Python to Go using gofpdf library, why we did this change, how we planned it and some insights we got along the way.

Extending Osquery with Go

Thu, 21 Dec 2017 00:00:00 +0000

What if you could use SQL to query any aspect of your infrastructure? Osquery, an open source instrumentation tool released by the Facebook security team allows you to do just that.

Tracking the Stars

Wed, 20 Dec 2017 06:40:42 +0000

In April 2017, I thought it would be fun to try setting up a system to track the star counts of the top 1000 Go repositories on GitHub.

Accessing SMBIOS information with Go

Tue, 19 Dec 2017 08:00:00 +0000

While speaking with coworkers recently, one of them posed a question: How can we discover the capacity of each memory DIMM in a machine?

Using Vue.js with Buffalo

Mon, 18 Dec 2017 00:00:00 +0000

When I’m writing web applications, I don’t tend use the latest JavaScript front-end hotness, instead I prefer to reload the entire page on a request, or at the most, a small section of it.

Go and wasm: generating and executing wasm with Go

Sun, 17 Dec 2017 09:15:00 +0000

Today we will see how we can interact with WebAssembly, from Go: how to execute WebAssembly bytecode from Go and how to generate WebAssembly bytecode with Go.

Seeking around in an HTTP object

Sat, 16 Dec 2017 00:00:00 +0000

Imagine there’s a giant ZIP file on a HTTP server, and you want to know what’s inside it. You don’t know if it’s got what you are looking for, and you don’t want to download the whole thing.

unsafe.Pointer and system calls

Fri, 15 Dec 2017 08:00:00 +0000

unsafe is a Go package that, as the official documentation states, contains operations that step around the type safety of Go programs. As its name implies, it should be used very carefully; unsafe can be dangerous, but it can also be incredibly useful.

Write a Kubernetes-ready service from zero step-by-step

Thu, 14 Dec 2017 00:00:00 +0000

If you have ever tried Go, you probably know that writing services with Go is an easy thing. Yes, we really need only few lines to be able to run http service.

gRPC Go: Beyond the basics

Wed, 13 Dec 2017 09:15:00 +0000

Introduction As a newcomer to gRPC (in Go) there are many resources setting out what gRPC is, where it originated from and how to create a basic service and client.

How to Tokenize Complex Strings with Lexmachine

Tue, 12 Dec 2017 00:40:42 +0000

This article is about using lexmachine to tokenize strings (split up into component parts) in the Go (golang) programming language. If you find yourself processing a complex file format or network protocol this article will walk you through how to use lexmachine to process both accurately and quickly.

Web Sessions and Common User Workflows - A Foundation for Go-Based Websites

Mon, 11 Dec 2017 00:00:00 +0000

Go is widely used to implement microservices and APIs. And for those wishing to set up a dynamic website without resorting to, say, Ruby or PHP, Go offers a lot of tools out of the box.

Parsing with ANTLR 4 and Go

Sun, 10 Dec 2017 00:00:00 +0000

What is ANTLR? ANTLR (ANother Tool for Language Recognition), is an ALL(*) parser generator. In layman’s terms, Antlr, creates parsers in a number of languages (Go, Java, C, C#, Javascript), that can process text or binary input.

Property Based Testing

Sat, 09 Dec 2017 06:40:42 +0000

Useful Programs I’ll start this post with a bold but fairly uncontroversial statement: Programs that do not interact with the outside world are useless - they do nothing except consume cycles.

Custom JSON unmarshaler for a GraphQL client

Fri, 08 Dec 2017 09:15:00 +0000

In this post, I will tell a story of how I had to build a custom JSON unmarshaler for the needs of a GraphQL client library in Go.

Repeatable and Isolated Development Environments for Go

Thu, 07 Dec 2017 00:00:00 +0000

One of the common criticisms of the GOPATH is that it is hard to create isolated development environments without resorting to hacks, bash scripts, multiple GOPATH settings, or other trickery.

Managing Dependencies, Forks, and Code Patches with Dep

Wed, 06 Dec 2017 00:00:00 +0000

A few months ago, we switched over to using dep to manage dependencies for Veneur. We were excited to discover that dep provided a straightforward workflow for a longstanding problem in Go development: managing forks of dependencies and contributions to upstream projects.

A Tale of Two `rand`s

Tue, 05 Dec 2017 00:40:42 +0000

I had always been a bit confused as to how the crypto/rand package and the math/rand package were related, or how they were expected to work (together).

Creating Your Own Bot Experience with go-sarah

Mon, 04 Dec 2017 00:00:00 +0000

Chat tools have been good friends of developers. On chat tools we share our thoughts, problems, solutions, jokes, and pretty much everything we do as software engineers.

Minimal Perfect Hash Functions

Sun, 03 Dec 2017 00:00:00 -0500

A regular hash function turns a key (a string or a number) into an integer. Most people will know them as either the cryptographic hash functions (MD5, SHA1, SHA256, etc) or their smaller non-cryptographic counterparts frequently encountered in hash tables (the map keyword in Go).

Automating Go development with Make

Sat, 02 Dec 2017 00:00:00 +0000

Make is an old tool that you can use today to help get everyone on your team on the same page, and make it easy for new contributors to your project to get started.

Using GopherJS with gRPC-Web

Fri, 01 Dec 2017 00:00:00 +0000

Introduction This article will talk about how to connect a GopherJS frontend to a Go backend. If you haven’t heard about GopherJS before, it’s an open source Go-to-JavaScript transpiler, allowing us to write Go code and run it in the browser.

2017 Advent Series Call for Submissions

Tue, 07 Nov 2017 05:26:58 -0500

It’s November, and once again our thoughts drift towards the holidays and the awesome blog posts that arrive as gifts to you in the Gopher Academy Blog.

Writing a successful GopherCon proposal

Sat, 14 Jan 2017 00:00:00 +0000

The GopherCon 2017 Call for Proposals has reached the halfway mark so I wanted to give potential speakers some specific advice when writing their proposals.

2016 Wrap Up

Sat, 31 Dec 2016 05:26:58 -0500

2016 was an amazing year for Go and for the Go community. New conferences popped up all over the globe, and there were some amazing new projects written in Go.

Go 1.8

Fri, 30 Dec 2016 00:00:00 +0000

With Go following a predetermined release schedule of February - August and a Release Candidate for Go 1.8 just a few days after this article, it looks like we should be able to talk about Go 1.

Introducing Go to your organization

Thu, 29 Dec 2016 00:00:00 +0000

Go is without a doubt a growing language. Some still consider it a young language, due to the fact that it was released “just” under 5 years ago.

Promoting the Quality and Collaboration of Your Open Source Project

Wed, 28 Dec 2016 00:00:00 -0800

So your open source project is on GitHub. It has tests, an awesome logo, probably a few stars, and maybe even a few other contributors.

Testing distributed systems in Go

Tue, 27 Dec 2016 08:00:00 +0000

What is etcd etcd is a key-value store for the most critical data of distributed systems. Use cases include applications running on Container Linux by CoreOS, which enables automatic Linux kernel updates.

A little bit of Machine Learning: Playing with Google's Prediction API

Mon, 26 Dec 2016 06:00:00 +0000

Before we get started, let’s begin by making clear that this isn’t going to be a deep dive on TensorFlow, neural networks, inductive logic, Bayesian networks, genetic algorithms or any other sub-heading from the Machine Learning Wikipedia article.

Writing an API Client in Go

Sun, 25 Dec 2016 00:00:00 +0000

Let’s say you need to write a client that talks to a third party API, like the AWS API, or the Twilio API. Go gives you a lot of tools that can help you write a really good client, but you have to know how to take advantage of them!

Predicting genetic diseases with CloudForest

Sat, 24 Dec 2016 00:00:00 +0000

CloudForest is a machine learning project dedicated to the construction of Random Forests built entirely in Go. It was created by Ryan Bressler. Random Forests are a machine learning algorithm based around the construction of many single classification trees, each splitting both the training set and the features available to train the model randomly.

Teaching Go to complete beginners

Fri, 23 Dec 2016 00:00:00 +0000

TL;DR How about arranging a GoBridge workshop for beginners as your New Year’s resolution? Teach Go to complete beginners Being a good Go programmer is definitely good.

Implementing Git's Compression In Go

Thu, 22 Dec 2016 00:00:00 +0000

Implementing Git’s Compression in Go Git + Go = Gitgo Gitgo is a pure Go library for core Git functions. As a ground-up implementation with no C bindings, it implements the entire structure of Git repositories from scratch.

Enigma emulator in Go

Wed, 21 Dec 2016 00:00:00 +0000

Introduction This story begins the day after I got home after giving a talk at the wonderful DevFest Siberia. Shortly after my weekly fix of Westworld, a strange nagging feeling appeared — like the one you get from unpaid bills, a postcard that you forgot to send, or a particularly nasty API endpoint that you were supposed to refactor a year ago but then, well, I mean, it works, right?

Gleam: Distributed Map Reduce for Golang

Tue, 20 Dec 2016 00:00:00 +0000

After developing Glow last year, I came to realize the two limitations of Go for distributed data processing. First, generics are needed. Of course, we can use reflection.

So you want to expose Go on the Internet

Mon, 19 Dec 2016 01:30:27 +0000

Back when crypto/tls was slow and net/http young, the general wisdom was to always put Go servers behind a reverse proxy like NGINX. That’s not necessary anymore!

Advanced Encoding and Decoding Techniques in Go

Sun, 18 Dec 2016 00:00:00 +0000

Advanced Encoding and Decoding Techniques Go’s standard library comes packed with some great encoding and decoding packages covering a wide array of encoding schemes. Everything from CSV, XML, JSON, and even gob - a Go specific encoding format - is covered, and all of these packages are incredibly easy to get started with.

Abusing Go Syntax to Create a Domain-Specific Language

Sat, 17 Dec 2016 00:00:00 -0800

Go is often the tool of choice for building the guts of a high-performance system, but Go was also designed with some features that are great for building high-level abstractions.

Writing good unit tests for SOLID Go

Fri, 16 Dec 2016 00:00:00 +0000

Dave Cheney covered how interfaces are used to design good Go code in his SOLID Go Design talk and blog post. In this blog post, we are going to focus on some tips on how to write unit tests for that beautiful SOLID code.

Finding good packages in the Sea of Open-Source

Thu, 15 Dec 2016 00:00:00 +0000

So far we’ve seen different ways to use Go to build a variety of applications, from versioning your data pipelines to building your own BBQ grill controller.

Goroutree: A tree-based set made of coordinating goroutines

Wed, 14 Dec 2016 00:00:00 +0000

This was one of those projects that sat in the back of my mind for quite a while. It was destined to join the many others in my side project graveyard unless I had a good reason to finish it, like a date for a blog post.

The Saga of Go Dependency Management

Tue, 13 Dec 2016 00:00:00 +0000

The Saga of Go Dependency Management The Go community is on the cusp of some major shifts in the way we handle dependencies. These shifts are a long time coming, and involve the work and effort of dozens, if not hundreds, of people.

Data Pipelines and Versioning with the Pachyderm Go Client

Mon, 12 Dec 2016 00:00:00 +0000

I know about Gophers, but what is a Pachyderm? Pachyderm is an open source framework, written in Go, for reproducible data processing. With Pachyderm, you can create language agnostic data pipelines where the data input and output of each stage of your pipeline are versioned controlled in Pachyderm’s File System (PFS).

Go and a Package Focused Design

Sun, 11 Dec 2016 00:00:00 +0000

Developers often tend to think about designing software in terms of using logical layers of abstractions. I have seen many Go projects with layers of abstractions that reflect grouping of all common things together such as types (model), handlers for all services (api or controllers), and even multi-purpose packages (util).

Some Tools For Go That You Might Not Know Yet

Sat, 10 Dec 2016 00:00:00 +0100

Year’s end is coming closer. Time to clean up repositories and polishing up the toolset. All the well-known tools have been installed already–is there anything else to add to the toolbox?

New features in go1.8 database/sql

Fri, 09 Dec 2016 00:00:00 +0000

database/sql has many new features to better enable writing and controlling queries. In short it adds support for: Cancelable queries Returning the SQL database types Returning multiple result sets Ping hitting the database server Named parameters Transaction isolation levels Cancelable Queries

Contributing to the Go project

Thu, 08 Dec 2016 08:00:00 +0000

Contributing to the Go project can seem overwhelming, especially at first. The official Contribution Guidelines document is rather lengthy, but after working through the initial Google CLA and Gerrit authentication process, it becomes much easier to contribute to the project.

QPID - Go Powered BBQ

Wed, 07 Dec 2016 05:26:58 -0500

Two of my favorite things to do are write Go code and make BBQ. This fall, I started a project that combined these passions into an interesting project.

Using NATS Messaging with some of your favorite Golang tools

Tue, 06 Dec 2016 00:00:00 -0800

Quick Intro to NATS, and Why We Love Go! For those of you who have been reading GopherAcademy for a while, you may already be familiar with NATS via last year’s post, or you may have known about NATS for a while before that - NATS was one of the earliest production applications written in Golang.

Using Go's 'context' library for making your logs make sense

Mon, 05 Dec 2016 00:00:00 +0000

One of the shiny new toys in Go 1.7 is the ‘context’ library. Not shiny as in it is genuinely new. It started out at golang.

How Do They Do It: Timers in Go

Sun, 04 Dec 2016 06:00:00 +0000

How Do They Do It: Timers in Go This article covers the internal implementation of timers in Go. Note that there are a lot of links to Go repo in this article, I recommend to follow them to understand the material better.

Go, Nginx, and TLS Termination

Sat, 03 Dec 2016 00:00:00 +0000

With the advent of Let’s Encrypt, it’s now easier than ever before to ensure all of your web applications and services are behind HTTPS. However, many times it’s hard to realize the performance impact and overhead of using HTTPS on your applications.

Writing Go assembly functions with PeachPy

Fri, 02 Dec 2016 00:00:00 +0000

What is PeachPy PeachPy is a Python-based framework for writing modules in assembly. It automates away some of the details and allows you to use Python to generate repetitive assembly code sequences.

December Blog Series Introduction

Thu, 01 Dec 2016 05:26:58 -0500

2016 has been a great year for the Go language and the Go community. We love to celebrate the end of the year with a series of blog posts from the community on a wide variety of topics.

GopherCon 2017 - Website Call for Volunteers

Thu, 01 Dec 2016 00:00:00 +0000

Calling all Gophers! Many of you have asked how you can volunteer to help with GopherCon - and here’s a great opportunity! We’re doing our best to keep overhead costs down and apply the savings to an even better conference experience.

GopherCon 2016 - Retrospective

Wed, 20 Jul 2016 00:00:00 +0000

GopherCon 2016 has come and gone, and in keeping with our tradition we wanted to write up a brief retrospective to capture some of the highlights of the event.

GopherCon 2016 - Lightning Talk Annoucement

Fri, 01 Jul 2016 00:00:00 +0000

GopherCon 2016 is going to be an amazing event, and this is your chance to be a part of it! First time speaker? Experienced Speaker?

GopherCon Turns Three

Wed, 20 Apr 2016 00:00:00 +0000

tl;dr We’re excited for the third anniversary of GopherCon, so we’re offering a discount on tickets valid only on the anniversary of the conference.

2015 Year in Review

Thu, 31 Dec 2015 08:00:00 +0000

Looking back on 2015 has humbled us here at Gopher Academy. What an amazing year we’ve had. Let’s review some of the highlights: We’ve published dozens of community-written articles.

2D Game Libraries for Go

Wed, 30 Dec 2015 00:00:00 +0000

By now, we all know that Go is a great language for writing servers and command line tools. But what about games? Can you make desktop, web, or mobile games in Go too?

etcd: distributed key-value store with grpc/http2

Tue, 29 Dec 2015 08:00:00 +0000

What is etcd? etcd is a distributed, consistent key-value store, written in Go. Similar to how Linux distributions typically use /etc to store local configuration data, etcd can be thought of as a reliable store for distributed configuration data.

Understanding and using the vendor folder

Mon, 28 Dec 2015 00:00:00 -0800

With the release of Go 1.5, there is a new way the go tool can discover go packages. This method is off by default and the surrounding tools, such as goimports, do not understand that folder layout.

Glow: Map Reduce for Golang

Sun, 27 Dec 2015 12:11:25 -0800

Having been a Java developer for many years, I have simply lost interest in Java and want to code everything in Go, mostly due to Go’s simplicity and performance.

Symmetric API Testing

Sat, 26 Dec 2015 00:00:00 -0500

I maintain Anaconda, the Twitter client library for Go. There are a lot of interesting things I could write about Anaconda - for example, automatic rate-limiting and throttling using the tokenbucket library.

Lessons in Go Learned while Implementing SHIELD

Fri, 25 Dec 2015 00:00:00 -0500

Quick background: What is SHIELD? SHIELD is a backup solution for Cloud Foundry and BOSH deployed services such as Redis, PostgreSQL, and Docker. (For the interested, here is a quick summary of the basics of BOSH and Cloud Foundry.

Tiny Linux OSes with Go

Thu, 24 Dec 2015 00:00:00 -0800

Small disclaimer: This is much more fun than it is useful For a while now, we’ve been seeing new “cloud” OSes crop up, like CoreOS and RancherOS.

Geographical data manipulation using go

Wed, 23 Dec 2015 08:00:00 +0000

GIS open source world is dominated by C/C++, Java and Python code. Libraries like PROJ4, JTS, GEOS or GDAL are at the core of most of the open source geospatial projects.

Composable Pipelines Improved

Tue, 22 Dec 2015 00:00:00 +0000

I wrote a post here on GopherAcademy earlier this year, about an idea for a “framework-less” pattern for Flow-Based Programming style programs in Go, or let’s just call it “composable concurrent pipelines”.

Hydra: Run your own Identity and Access Management service in <5 Minutes

Mon, 21 Dec 2015 00:00:00 +0100

This article introduces Hydra, the open source micro service alternative to proprietary authorization solutions. It will take you less than five minutes to start up a OAuth2 provider and gain access to a rich features set, including access control and identity management.

Automi: Stream Processing Over Go Channels

Sun, 20 Dec 2015 00:00:00 -0500

As a Go programmer, one of the features that attracted me to the language is the channel-based idiom used for goroutine communications. Channels, along with goroutines, form the basis for the Go concurrency primitives.

Writing an SSH server in Go

Sat, 19 Dec 2015 00:00:00 +0000

When I’m working on the Gogs project, there is a need of builtin SSH server, which allows users to preform Git-only operations through key-based authentication.

Manage Dependencies Like Other Languages With Glide

Fri, 18 Dec 2015 08:00:00 -0500

Managing dependent packages in most of the popular and new languages have common patterns implemented by package managers. If you need to manage packages in Python, JavaScript, Rust, Java, Ruby, C# (via .

gopy: extending CPython with Go

Thu, 17 Dec 2015 00:00:00 +0100

Applications and libraries do not live in a vacuum. This is of course true for Go packages and commands. More often than not, you need your code to interact with legacy applications or old and battle tested libraries.

NATS: High Performance Cloud Native Messaging Written in Go

Wed, 16 Dec 2015 13:45:04 -0500

Performance at scale is critically important for anybody attempting to build distributed systems today. Pieces of a given service might be spread across physical or virtual infrastructure, or might be comprised of thousands or even millions of devices (Internet of Things).

Generate and Use Free TLS Certificates with Lego

Tue, 15 Dec 2015 08:00:00 -0700

If your Go program uses the transport layer of the network at all—whether to serve static files, an API, or something else over the wire—you should be encrypting connections using TLS.

test2doc: Generate Your API Docs

Mon, 14 Dec 2015 22:04:31 -0800

API docs are important. We all know that. They are also painful and tedious to maintain. When your docs aren’t accurate, you get more questions.

Integrating Go in a Yocto-based project

Sun, 13 Dec 2015 00:00:00 -0600

From its website, Yocto, part of the Linux Foundation Collaborative Projects, is an open source collaboration project that provides templates, tools and methods to help you create custom Linux-based systems for embedded products regardless of the hardware architecture.

Composable command-line tools

Sat, 12 Dec 2015 00:00:00 -0800

Go’s simplicity and exhaustive standard library means writing command-line tools is easy and enjoyable. Following the Go philosophy, if you write programs that are small and focussed, you can end up with a pretty powerful little toolbelt of utilities.

Announcing GopherCon 2016

Fri, 11 Dec 2015 08:00:00 +0000

GopherCon 2016 will take place at the Colorado Convention Center in Denver, Colorado on July 11th through July 13th, 2016. We’ve listened to the feedback you gave us from GopherCon 2015 and want to explain the changes we’re putting in place for GopherCon 2016.

Reducing boilerplate with go generate

Thu, 10 Dec 2015 08:00:00 +0000

Go is an awesome language. It’s simple, powerful, has great tooling and many of us really enjoy using it every day. However, as it usually happens with strongly typed languages, we write a good deal of boilerplate to connect things around.

Hooking libc using Go shared libraries

Wed, 09 Dec 2015 08:00:00 +0000

Alastair O’Neill gave a talk at the BSides Manchester security conference in August about userland rootkits that use the LD_PRELOAD mechanism. Most of these rootkits are written in C.

Go in a Monorepo

Tue, 08 Dec 2015 08:00:00 +0000

A “monorepo” is a monolithic code repository which contains many different projects and libraries. At DigitalOcean, we have created a monorepo called cthulhu to house all of our Go code.

goa: Untangling Microservices

Mon, 07 Dec 2015 00:00:00 +0000

goa: Untangling microservices The Raise of Microservice Architectures and APIs After suffering through a monolithic Rails application for a number of years, we (the RightScale Engineering team) shifted our focus to microservice architectures.

Smart Cryptography with Superdog and Vault

Sun, 06 Dec 2015 08:28:59 -0500

Superdog - the Crypto library for Vault from Hashicorp At XOR Data Exchange we deal with a lot of sensitive data for our customers. We needed to be able to support strong encryption with key rotation in a simple and practical way.

Go Fuzz

Sat, 05 Dec 2015 08:00:00 +0000

In April of this year, Dmitry Vyukov released the first version of go-fuzz, a coverage-guided fuzz testing tool based on ideas from afl. With very little fanfare, he unleashed it on the Go standard library and started filing huge numbers of crashers and other bugs found via automated, randomized testing.

afero: A Universal Filesystem Library

Fri, 04 Dec 2015 08:17:26 -0500

Anyone who spends a few minutes talking with me about development knows I love Go. My Github and Blog are practically a love letter to the language.

Debugging Go programs with Delve

Thu, 03 Dec 2015 08:00:00 +0000

Tracking down bugs in your code can be a very frustrating experience. This is even more true of highly parallel code. Having a good debugger at your disposal can make all the difference when it comes to tracking down a difficult, or hard to reproduce bug in your code.

Working with Semantic Versions

Wed, 02 Dec 2015 08:00:00 +0000

Semantic Versioning (a.k.a SemVer) has become a popular way to handle versions. The structure not only allows for incremental releases but allows people and automation to deduce what those changes mean.

December Blog Series Introduction

Tue, 01 Dec 2015 05:26:58 -0500

It’s that time of year again… The time when young gophers dream of high-quality articles about Go programming. We’ve run our “Advent” series at GopherAcademy for two years now, and it has been by far the most successful content we’ve ever published.

GopherCon 2015 lightning talk results

Thu, 25 Jun 2015 00:00:00 +0000

Registrations for the GopherCon’s Hack Day talks closed on the 20th of July, here are the results. Forward After the popularity of the lightning talk sessions last year, and the huge interest the call for papers received, we expected very high demand for lightning talk slots this year.

GopherCon Friday Hack Day details

Mon, 15 Jun 2015 00:00:00 +0000

With less than a month til GopherCon 2015 we’ve been hard at work on plans for the Friday 10th Hack Day. The previous year’s unofficial Friday Hack Day was so popular we decided this year to integrate it into the conference proper.

GopherCon 2015 lightning talk registrations

Fri, 05 Jun 2015 00:00:00 +0000

Friday the 10th of July is GopherCon’s Hack Day. By popular request we’re going to be running lightning talks in main theatre most of the day.

A Look Inside Caddy, a Web Server Written in Go

Wed, 27 May 2015 00:00:00 +0000

Caddy is a unique web server with a modern feature set. Think nginx or Apache, but written in Go. With Caddy, you can serve your websites over HTTP/2.

A unique Gophercon 2015 souvenir

Tue, 26 May 2015 00:00:00 +0000

A unique Gophercon 2015 souvenir

We’re excited to announce something that we’ve been working on behind the scenes for quite a while.

As a gift to GopherCon 2015 attendees who book hotel accommodation through one of our hotel partners, on check in, you will receive one of these as the key to your room:

Introducing Congo

Mon, 25 May 2015 15:07:34 +0900

Congo - an upcoming Conference Management Tool While we absolutely love running GopherCon, one thing jumps out as the most troublesome aspect of managing a large conference: managing the data.

GopherCon 2015 - Tickets selling fast

Thu, 14 May 2015 00:00:00 +0000

GopherCon 2015 tickets selling fast We’re delighted to announce that this week GopherCon 2015 ticket sales have passed the 1,000 mark! This means that there are less than a third of all tickets remaining.

GopherCon 2015 - Speakers Round 3

Wed, 22 Apr 2015 00:00:00 +0000

We’ve just published our third and final set of speakers for GopherCon 2015. These final five speakers mark the completion of the speaking programme for 2015.

GopherCon 2015 - Speakers Round 2

Fri, 17 Apr 2015 12:00:00 -0400

GopherCon 2015 is on track to be the most amazing Go conference ever held. Our tradition of bringing you the best speakers and most interesting topics continues with today’s release of the second round of speakers.

GopherCon 2015 - Speakers Round 1

Fri, 10 Apr 2015 12:37:00 -0400

Call for Papers The GopherCon 2015 Call for Papers was an incredible success. We received over 164 submissions from people all over the world. Our panel of 12 community members worked tirelessly to review and rate each proposal.

The Golang UK Conference

Wed, 01 Apr 2015 20:30:00 +0000

At last, the UK community has decided to organise a Go conference for the UK and rest of the world! Save the date: Friday 21st August 2015.

gobench - Go Benchmark Competition

Fri, 27 Mar 2015 15:07:34 +0900

Introduction Simplicity is one of the philosophies of Go. Rob Pike said that the secret of Go’s success is in its simplicity at Go Conference 2014 autumn in Tokyo, Japan.

Docker 2nd Birthday & Open-source-a-thon

Fri, 20 Mar 2015 17:37:05 -0400

For Docker’s 2nd birthday they’ve been planning something that we think is pretty amazing. Starting March 23rd, the Docker & Go communities will be hosting dozens of open-source-a-thon parties around the world.

Code Generation From the AST

Fri, 13 Mar 2015 12:50:47 -0700

Deprehend is a tool that auto-generates go src to wrap goroutines with panic handlers and wrap http handlers for metrics tracking. Over at DeferPanic we do a lot of application monitoring specifically for you, Go engineers.

Patterns for composable concurrent pipelines in Go

Thu, 26 Feb 2015 00:00:00 -0800

Patterns for composable concurrent pipelines in Go The undersigned came into the world of Go from Python, which is quite prevalent in the field of bioinformatics.

GopherCon India 2015

Tue, 24 Feb 2015 21:00:00 +0000

I came to GopherCon India not knowing what to expect, but from the moment I arrived it was nothing short of spectacular. I talked to amazing people who genuinely appreciated that members of the global community came to India to participate in the event.

Data mining with Go

Mon, 02 Feb 2015 17:10:37 +0100

What is the idea behind Gopher Gala project heatingeffect? Heating Effect provides a visual representation of the raw notice data from (chillingeffects.org). The Chilling Effects database collects and analyzes legal complaints and requests for removal of online materials, helping Internet users to know their rights and understand the law.

Go and the Secure Shell protocol

Tue, 13 Jan 2015 09:00:00 +0000

What is the Secure Shell protocol? Many of us use ssh(1) everyday to administer servers around the world. The Secure Shell protocol, however, allows us to do much more than open secure shells.

The world's first Go distributed hackathon.

Sat, 03 Jan 2015 13:12:45 -0600

Registration is now open for the Gopher Gala - the world’s first Go distributed hackathon. You may have heard of the Rails Rumble, Node Knockout, or Django Dash.

Cron as a file system

Mon, 29 Dec 2014 13:12:45 -0600

9p I read The Styx Architecture for Distributed Systems over a decade ago. The central idea of the paper is that “representing a computing resource as a form of file system, [makes] many of the difficulties of making that resource available across the network disappear”.

The Other Side of Go: Programming Pictures, the Read, Parse, Draw Pattern

Thu, 25 Dec 2014 17:10:00 +0500

The other side of Go: Programming Pictures, the Read, Parse, Draw Pattern Go has proven to be extremely versatile and well suited to back-end tasks, but sometimes you need a picture, and I’ve found that Go works well for generating visuals as well.

Type safe templating with ego

Wed, 24 Dec 2014 00:00:00 -0800

Go has seen many converts from scripting languages such as Ruby and Python. These newcomers love the type safety, the language simplicity, and the static binaries that Go offers.

Viper: Configuration with Fangs

Tue, 23 Dec 2014 10:40:33 -0800

One of the hardest things to get right when building command line or server applications is user configuration. One look at the many different INI formats or various approaches used in /etc demonstrates that there really isn’t a good and standard approach.

Testing Microservices in Go

Mon, 22 Dec 2014 00:00:00 -0800

This post is about testing microservices and why they should be tested differently from many types of software. Microservices are by their very nature simple and encapsulated behind their api.

Managing Dependencies

Sun, 21 Dec 2014 08:00:00 +0000

Packages, dependencies, versions. This post will explore two tools and how I’ve been using them. Godep as the consumer of third-party packages, and gopkg.in as a library author.

Cobra: A Modern & Refined CLI Commander

Sat, 20 Dec 2014 10:30:19 -0800

Go is the perfect language to develop command line applications. Go has a few advantages that really set it apart from other languages: Single binary Very fast execution time, no interpreter needed Go is awesome!

Simple backoff

Fri, 19 Dec 2014 08:00:00 +0000

Or, taming connection state and thundering herds. There comes a time in the life of many programs when you need to maintain a persistent connection to a server.

Atlas: Building with Rails and Go Microservices

Thu, 18 Dec 2014 08:00:00 +0000

Atlas is a recently announced service by HashiCorp that provides a single platform to take an application from development through to production. The complexity of the problem makes Atlas a sophisticated web service that is composed of many moving pieces.

Soy - Programmable templates for Go, Java, JS

Wed, 17 Dec 2014 08:00:00 +0000

Closure Templates (aka Soy Templates) is a client and server-side templating language developed at Google. The Go implementation exposes the the internal structure of the template (the AST).

Wrapping Git in rc shell

Tue, 16 Dec 2014 08:00:00 +0000

Wrapping Git in rc shell Introduction When Rob Pike announced the migration of Go from Mercurial and Rietveld to Git and Gerrit, like most people, I was pretty enthusiastic.

The Case Against Third Party Libraries

Mon, 15 Dec 2014 08:00:00 +0000

Or how I learned to stop worrying and love versionless package management If you spend any time on the golang-nuts mailing list you’ll learn that the only thing more contentious than generics is package management.

Using a JSON File as a Database Safely in Go

Sun, 14 Dec 2014 00:00:00 -0800

There are definitely problems with using a json file as a database, but sometimes the simplicity of no extra dependencies makes it an attractive option.

Probabilistic Data Structures for Go: Bloom Filters

Sat, 13 Dec 2014 08:00:00 +0000

In part one, I talked about some interesting probabilistic data structures.. In part two, I will discuss a more common approximate data structure: Bloom filters and their variations.

goquery: a little like that j-thing

Fri, 12 Dec 2014 00:00:00 -0800

A little over 2 and a half years ago I started playing with that new language called Go. Coming mostly from .NET and node.js, I was at first intrigued by its concurrency features and its lack of object inheritance, and impressed by the quality of the team behind it.

Writing file systems in Go with FUSE

Thu, 11 Dec 2014 08:00:00 +0000

Motivation Some time ago, I decided I wanted to solve my own storage needs better, and I realized that I can’t just rely on synchronizing files.

Easy Docker Deployment with Hooks and Captain Hook

Wed, 10 Dec 2014 08:00:00 +0000

Deploying with “git push” the Docker Way Many people have asked me how we set up the GopherAcademy blog to automatically deploy when we push a commit.

Patchwork Toolkit - Lightweight Platform for the Network of Things

Tue, 09 Dec 2014 18:00:00 +0000

Patchwork is a toolkit for connecting various devices into a network of things or, in a more broad case - Internet of Things (IoT). A tl;dr picture describing the idea behind it is shown below.

Nigel's WebDAV package

Mon, 08 Dec 2014 08:00:00 +0000

Nigel Tao and Nick Cooper have been working on a new WebDAV package for the golang.org/x/net repository. The package is still in its formative stages, so this isn’t a review of the package itself.

Reading config files the Go way

Sun, 07 Dec 2014 08:00:00 +0000

In the middle of writing my blog engine dynocator, I wondered about the best possible way to read data from a config file. My first approach was to read line by line from the file and use the wonderful strings package to parse the data I want.

Macaron: Martini-style, but faster and cheaper

Sat, 06 Dec 2014 08:00:00 +0000

Macaron is a high productive and modular design web framework in Go. It takes basic ideology of Martini and extends in advance. Why another web framework?

String Matching

Fri, 05 Dec 2014 08:00:00 +0000

How do you search for a string? If it’s just once, strings.Index(text, pattern) is probably your best option. The standard library currently uses Rabin-Karp to search the text for the pattern.

Git2go inception

Thu, 04 Dec 2014 08:00:00 +0000

How many levels of inception we need to master git? This tutorial that explains how to use git2go to publish an article for the Go Advent 2014.

Delve: Go debugger

Wed, 03 Dec 2014 08:00:00 +0000

Delve Delve is a Go debugger. Currently the project is in beta, with most of the functionality implemented, and various improvements and platform support on the way.

Handwritten Parsers & Lexers in Go

Tue, 02 Dec 2014 00:00:00 -0600

Handwritten Parsers & Lexers in Go In these days of web apps and REST APIs it seems that writing parsers is a dying art. You may think parsers are a complex undertaking only reserved for programming language designers but I’d like to dispel this idea.

Probabilistic Data Structures for Go

Mon, 01 Dec 2014 08:00:00 +0000

Imagine you had access logs for a very high traffic website. How would you determine how many different IP addresses accessed your site? Or how many hits from a particular IP?

Using Go for Anomaly Detection

Sat, 29 Nov 2014 08:00:00 +0000

As engineers, we need to know how our applications and services are performing in realtime and isolate any problems as quickly as possible. While there is a plethora of tools to collect, store and graph metrics from infrastructure, there are fewer tools for performing analysis on these metrics.

Go at Sourcegraph - Serving Terabytes of Git Data, Tracing App Performance, and Caching HTTP Resources

Fri, 28 Nov 2014 00:00:00 +0000

Sourcegraph is a code search and review application that supports and analyzes code in multiple languages: Go, Python, Java, Ruby, JavaScript, and soon more. Even though we have experts in each language on our team, Sourcegraph’s core has been written in Go since day one, and we’ve chosen Go for each new project and system we’ve built.

Go at Datadog

Thu, 27 Nov 2014 00:00:00 -0600

Go at Datadog In the last year, Go has started to supplant parts of our intake pipeline at Datadog that were previously written in Python.

Advanced Reflection with Go at HashiCorp

Wed, 26 Nov 2014 00:00:00 -0800

Advanced Reflection with Go at HashiCorp HashiCorp builds a diverse set of popular DevOps tools written in Go: Packer, Serf, Consul, and Terraform. While these tools range from desktop software to highly scalable distributed systems, their internals all have one thing in common: they use reflection, and a lot of it.

Go at CoreOS

Tue, 25 Nov 2014 00:00:00 -0800

Go at CoreOS When we launched the CoreOS project we knew from the very beginning that everything we built would be written in Go. This was not to make a fashion statement, but rather Go happened to be the perfect platform for reaching our goals – to build products that make distributed computing as easy as installing a Linux distro.

How Go Helped Shape Splice's engineering culture

Mon, 24 Nov 2014 00:00:00 -0800

Go is a trendy programming language, but let’s be honest: the Go language doesn’t have anything new that wasn’t first implemented somewhere else. As a matter of fact, Go is a pretty boring programming language.

Kite: Library for writing distributed microservices

Sun, 23 Nov 2014 00:00:00 -0600

Writing web services with Go is super easy. The simple but powerful net/http package lets you write performant web services in a very quick way.

OpenShift 3 and Go: Teaching Old Dogs New Tricks

Sat, 22 Nov 2014 00:00:00 -0600

The first commit to OpenShift (the Platform as a Service that is so hipster that we were doing containers even before it was cool) was four years ago.

Inspeqtor

Fri, 21 Nov 2014 00:00:00 -0600

When I decided to build Inspeqtor (source), I had a fundamental choice: what language should I build it in? I’ve worked in Ruby for the last 8 years so it was a natural choice: “use the tool you know best” is never a bad choice when solving your own problem.

Gogs: GitLab alternative in Go

Thu, 20 Nov 2014 00:00:00 -0600

What is Gogs and why we make it? Gogs is a painless self-hosted Git Service written in Go. It aims to make the easiest, fastest and most painless way to set up a self-hosted Git service.

Updating your Go packages with Go Package Store

Wed, 19 Nov 2014 00:00:00 -0600

Go Package Store is an app that displays updates for the Go packages in your GOPATH. Why another way to update Go packages when you can already just do go get -u, you might think.

Building Street Address Autocomplete with Go

Tue, 18 Nov 2014 00:00:00 -0600

Almost two years ago, SmartyStreets began an exodus from the .NET platform. What would take its place? Go. Before moving our entire code base from .

Going fast at startups

Mon, 17 Nov 2014 00:00:00 -0600

FullStory is a tool for understanding website visitors in a whole new way. An in-page script captures everything that happens during a user’s online session, including the entire DOM and every mutation.

Bleve: Text Search Powered by Go

Sun, 16 Nov 2014 00:00:00 +0000

Bleve, a text indexing and search library for Go, is excited to be part of the celebration of the 5th birthday of Go. Building a complete solution for indexing and search text requires integrating many different technologies. Go, the language, the standard library, the whole ecosystem, combine to make this not only possible, but fun.

How Continuum ended up being written in Go

Sat, 15 Nov 2014 00:00:00 -0600

In March of 2012, I had just left VMware and the project I had founded, architected and built, Cloud Foundry. PaaS then was still very new, as was a distributed system built in Ruby.

Using Go in government

Fri, 14 Nov 2014 00:00:00 -0600

When the UK Government Digital Service (GDS) started working on GOV.UK, much of it was built in Ruby. Since then, we’ve used a number of different programming languages across government including Java, Clojure, Scala, Python and Javascript.

To be Concurrent or Not to be? Sometimes Both

Thu, 13 Nov 2014 00:00:00 -0600

Go really makes concurrency easy. That said, there’s still some things to watch out for and not every 3rd party package you find out there is ready to have “go” put in front of its functions.

Why InfluxDB is written in Go

Wed, 12 Nov 2014 00:00:00 -0800

InfluxDB is an open source time series database written in Go. One of the important distinctions between Influx and some other time series solutions is that it doesn’t require any other software to install and run.

Kubernetes + Go = Crazy Delicious

Tue, 11 Nov 2014 00:00:00 -0800

What is Kubernetes? And what kind of name is that? Kubernetes is a container cluster management system. Modeled after Google’s internal systems, Kubernetes (or k8s for short) allows users to schedule the running of Docker containers over a cluster of machines.

Introducing the Go Birthday Bash 2014

Mon, 10 Nov 2014 00:00:00 -0800

The Go Birthday Bash Today is a special day for Go enthusiasts across the globe. We’re celebrating the 5th birthday of a programming language, and perhaps just as importantly: a community.

Welcome to the new Gopher Academy Blog

Fri, 07 Nov 2014 06:40:42 +0000

Welcome Gopher Academy is focused on bringing Gophers together. Our yearly conference GopherCon is a great example of our commitment to building a strong and inclusive community around the Go programming language.

Automatically Deploy A Revel Web Application

Wed, 09 Jul 2014 06:40:42 +0000

Introduction The websites that power GopherAcademy and GopherCon are written using Revel, which is a very nice framework for building web applications. Go has a great built-in HTTP server, but there are times when you don’t want to roll-your-own web framework.

Join Our New Slack Community For Gophers

Mon, 12 May 2014 06:40:42 +0000

Why Are We Doing This? GopherCon was an amazing experience for many of us who had the privilege to go. We met so many great people.

GopherCon 2014 Retrospective(Denver, Colorado - 2014)

Fri, 02 May 2014 06:40:42 +0000

It’s a Wrap Gophercon 2014 is in the books. In the end, we had 700 attendees, and it looks to us like everyone enjoyed the experience.

Gogs: Binary Deployment: The Right Way to Deploy

Tue, 01 Apr 2014 06:40:42 +0000

Gogs: When you’re deploying a binary, you’re doing it Right. This post is published corresponding to the Gogs - Go Git Service v0.2.0 release.

Go development environment for Vim

Sat, 29 Mar 2014 06:40:42 +0000

Go development environment for Vim The reason for creating vim-go Go has a very versatile toolchain and commands that makes Go programming fun. One of the famous tools is gofmt, which automatically reformats the code according to some predefined rules.

Plumbing and Semantics: Communication Patterns in Distributed System

Thu, 06 Feb 2014 06:40:42 +0000

Introduction In distributed systems, multiple components running on different machines—physical or virtual—communicate and coordinate to accomplish tasks. Distributed systems building typically focuses on the way components communicate.

Moving to Go: A Pragmatic Guide

Mon, 27 Jan 2014 06:40:42 +0000

Moving to Go You’ve read all the blog posts about how great Go is. You’ve lost patience with your monolithic framework of choice—Ruby on Rails, Django, etc.

GopherCon 2014 Scholarship for Women

Wed, 15 Jan 2014 06:40:42 +0000

Announcing the GopherCon Scholarship Program Today I’d like to announce the GopherCon Scholarship Program. It’s goal is to increase the visibility of women in the Go community through the most direct path I can imagine: sponsoring their attendance to GopherCon 2014.

Writing a Distributed Systems Library in Go

Mon, 06 Jan 2014 06:40:42 +0000

Writing a Distributed Systems Library in Go Introduction In early 2013, I needed to add distributed processing and storage to my open source behavioral analytics database.

Go Advent Day 25 - Announcing GopherCon 2014 Speakers

Wed, 25 Dec 2013 06:40:42 +0000

Go Advent This posting brings to a close the Go Advent series that started on December 1st. We’ve had some amazing posts from all around the Go community.

Go Advent Day 24.5 - Thank you

Tue, 24 Dec 2013 11:58:42 +0000

Thank you So far this year’s Go Advent has generated over 60k unique page views and exists as a permanent resource for the future. In this penultimate post we’d like to recap the contributions by our fantastic authors.

Go Advent Day 24 - Channel Buffering Patterns

Tue, 24 Dec 2013 06:40:42 +0000

Introduction One common method for message processing in Go is to receive from an input channel and write to an output channel, often using intermediate channels for message transformation and filtering.

Go Advent Day 23 - Multi-Platform Applications: Architecture and Cross-Compilation

Mon, 23 Dec 2013 06:40:42 +0000

Introduction While Go is touted for its utility on the server side and in networked environments, Go is incredibly powerful as a client-side (desktop) application language as well.

Go Advent Stocking Stuffer Bonus - Ginkgo and Gomega: BDD-Style Testing For Go

Mon, 23 Dec 2013 06:40:42 +0000

Ginkgo and Gomega: BDD-Style Testing For Go Agile software development is all about discipline, and disciplined agile developers test-drive their code: with a comprehensive test suite, refactoring and adding new features becomes substantially less stressful and time-consuming.

Go Advent Day 22 - A Journey Into NSQ

Sun, 22 Dec 2013 06:40:42 +0000

Introduction (NSQ is a realtime distributed messaging platform. It’s designed to serve as the backbone of a modern infrastructure composed of loosely connected services running on many computers.

Go Advent Day 21 - Two Factor Authentication in Go

Sat, 21 Dec 2013 06:40:42 +0000

Introduction Every day we hear about another site getting hacked and more passwords being leaked. Bad passwords and password reuse are two of the biggest problems with the human side of computer security.

Go Advent Day 20 - Go in Academia: Emulating Wireless Networks

Fri, 20 Dec 2013 06:40:42 +0000

How I Came to This TL;DR; — We didn’t want to use simulators and using real device for experiments became infeasible, so I decided to build an emulator for 802.

Go Advent Day 19 - Eject the Web

Thu, 19 Dec 2013 06:40:42 +0000

Editors Note: Yasuhiro is not a native English speaker, so during the editing of this post is was necessary to make some minor corrections. We felt that it was very important however, that the Author’s original phrasing and intent be preserved as much as possible.

Go Advent Day 18 - Go Outside

Wed, 18 Dec 2013 06:40:42 +0000

Introduction Outside is a Go package to dynamically link to and execute functions in Windows Dynamic Link Libraries and Linux Shared Libraries. Its current status is ‘prerelease’ with only 32-bit register size implemented and tested so far.

Go Advent Day 17 - Pond: a New RSS+Atom Syncing Protocol

Tue, 17 Dec 2013 06:40:42 +0000

The Problem We’re standing on the verge of a new era of data ownership and privacy, with decentralization and cryptography taking center stage on the technical side of things.

Go Advent Day 16 - Coconut: a pure Go blogging engine

Mon, 16 Dec 2013 06:40:42 +0000

Quickstart Coconut is a simple blogging engine. It has two kinds of content: Articles and Pages. Articles are stored in the articles directory and can be requested by using their file name (minus the required “.

Go Advent Day 15 - Accelerating ecommerce with Go

Sun, 15 Dec 2013 06:40:42 +0000

Welcome Writing an ecommerce site in Go Go adoption in the enterprise is increasing since the 1.0 release. Large respected tech companies have been using Go to build interesting back end services like etcd, specialized content delivery systems like dl.

Go Advent Day 14 - gobrew

Sat, 14 Dec 2013 06:40:42 +0000

What is gobrew? Simply put, gobrew lets you easily switch between multiple versions of go. It is based on rbenv and pyenv. Why gobrew? Often times you’ll be developing against one version of Go when another version is released (or perhaps a release candidate is made available).

Go Advent Day 13 - Go web services with Tiger Tonic

Fri, 13 Dec 2013 06:40:42 +0000

Welcome Go is unique among mainstream programming languages in that its standard library web server is not a complete afterthought. The Go language is well-suited for engineering complex networked services and Go’s standard library recognizes that many (if not most) of those services communicate via HTTP.

Go Advent Day 12 - Inside the Go Playground

Thu, 12 Dec 2013 06:40:42 +0000

From-the-state’s-secret-department Today’s post comes to us from the Go team’s own Andrew Gerrand. Reporting from deep inside an undisclosed location, Andrew lifts the lid on one of Go’s greatest mysteries: how does the Go Playground work?

Go Advent Day 11 - Build a Christmas List with Martini

Wed, 11 Dec 2013 06:40:42 +0000

Introduction Martini is a Go package for web server development that has gained quite a bit of popularity over the last month. Martini was written to help make web development in Go a convenient, expressive, and DRY (pun intended) process.

Go Advent Day 10 - Beyond Static Binaries

Tue, 10 Dec 2013 06:40:42 +0000

Introduction Today we’re going to go against the general theme of the Go Advent Calendar and introduce No New Hotness™. That’s because today is all about why folks in IT operations <3 go.

Go Advent Day 9 - Building A Weather App In Go

Mon, 09 Dec 2013 06:40:42 +0000

Introduction At Ardan Studios we have spent the last 6 months, in our spare time and on weekends, building a consumer based mobile application called OutCast.

Go Advent Day 8 - Doctor Who and the mutant Go compilers

Sun, 08 Dec 2013 06:40:42 +0000

At the end of 1963 the UK was in the grip of Beatlemania, but for an impressionable 7-year old like me, it was the arrival of Doctor Who that really fired my imagination.

Go Advent Day 7 - A Router for GOV.UK

Sat, 07 Dec 2013 06:40:42 +0000

Introduction When we set out to build GOV.UK, the new home for UK Government information and services, we decided up front that we wanted an architecture that would allow us to build very focussed applications that did one thing well.

Go Advent Day 6 - Service Discovery with etcd

Fri, 06 Dec 2013 06:40:42 +0000

Introduction At Poptip, our first foray into Go was a small but critical service that required extremely high throughput for a non-trivial amount of text processing.

Go Advent Day 5 - An introduction to beego

Thu, 05 Dec 2013 06:40:42 +0000

An introduction to beego Beego is an open-source, high-performance and lightweight application framework for the Go programming language. It supports a RESTful router, MVC design, session, cache intelligent routing, thread-safe map and many more features that you can check out here.

Go Advent Day 4 - GoConvey

Wed, 04 Dec 2013 06:40:42 +0000

Introduction One highly appealing aspect about Go is built-in testing with go test. From one who once eschewed test-driven development, I now wholly encourage it.

Go Advent Day 3 - Building a Twelve Factor App in Go

Tue, 03 Dec 2013 06:40:42 +0000

Introduction I’ve been writing a lot of Go code lately, but only recently discovered the Twelve Factor App manifesto. Coming from an Operations background I really resonated with many of the topics and solutions covered by Twelve Factor.

Go Advent Day 2 - Go 1.2 performance improvements

Mon, 02 Dec 2013 06:40:42 +0000

Introduction 7 months, 1600 changes, well over 350 issues closed¹, and Go 1.2 is done. Go and install it now – it’s ok, it only takes a few minutes – I’ll wait.

Go Advent Day 1 - Go 1.2 is released

Sun, 01 Dec 2013 06:40:42 +0000

Welcome Welcome to our first Go Advent Calendar. Gopher Academy is bringing you 25 blog posts about Go in 25 days and we’re starting from the top with a blog post from the Go team themselves.

Go Advent 2013 starts next week

Mon, 25 Nov 2013 06:40:42 +0000

Introduction Over at GopherAcademy, we’re getting in the Christmas spirit a little early this year. We’ve decided to do a Go Advent Calendar, highlighting cool Go projects every day from December 1st through the 25th.

SkyDNS (Or The Long Road to Skynet)

Thu, 10 Oct 2013 06:40:42 +0000

SkyDNS and Skynet This article is in two sections. The first is the announcement of SkyDNS, a new tool to help manage service discovery and announcement.

Recursion and Tail Calls in Go

Tue, 23 Jul 2013 06:40:42 +0000

Introduction This guest post is written by William Kennedy, author of the Going Go blog. I was looking at a code sample that showed a recursive function in Go and the writer was very quick to state how Go does not optimize for recursion, even if tail calls are explicit.

Introducing Gopher Academy

Tue, 09 Jul 2013 06:40:42 +0000

Introduction The people behind Gopher Academy have been active Go developers and contributors for several years. The Go ecosystem is vibrant, active, and full of smart people, but we always felt like it was missing a strong presence outside of Google.

Mon, 01 Jan 0001 00:00:00 +0000