Below you will find pages that utilize the taxonomy term “go”
Posts
Migrating to Hugo
This is now my third attempt at migrating from Jekyll to Hugo. I’m writing this post before I finish the migration. Luckily, because this is my third attempt, I’m confident I will see it through to the end.
After following the Hugo quickstart guide, I imported my Jekyll posts
hugo import jekyll ../../my-blog/ . --force enabled syntax highlighting
hugo gen chromastyles --style=monokai > syntax.css and turned on the configurations for highlighting adding the following to my config.
Posts
Go and Unix files
I ran into an odd Unix filename issue while writing Go code the other day.
Here’s a simplified example:
Let’s read a json file and unmarshall its contents into a struct in go. First, let’s set an environment variable with our file name to avoid hardcoded constants in our program.
export MY_FILE="/Users/dancorin/Desktop/test.json " Now, let’s read the file into our struct:
package main import ( "encoding/json" "fmt" "io/ioutil" "os" ) // Stuff struct holds the json contents type Stuff struct { Test string `json:"test"` } func main() { stuff := Stuff{} place := os.
Posts
Debugging go code with delve
Delve is a debugger for the Go programming language. The goal of the project is to provide a simple, full featured debugging tool for Go.
If we run our go service using a Makefile, with a command like make run, it can hard to find where to hook in and call dlv debug. We can get around this issue by attaching the delve debugger to our running service instead.
Posts
Go scope
Scoping in Go is built around the notion of code blocks. You can find several good explanations of how variable scoping work in Go on Google. I’d like to highlight one slightly unintuitive consequence of Go’s block scoping if you’re used to a language like Python, keeping in mind, this example does not break with Go’s notion of block scoping:
Let’s start with a common pattern in Python:
class Data(object): def __init__(self, val): self.
Posts
Tracking a call stack in Go with context
The use of context in Go can help you pass metadata through your program with helpful, related information about a call. Let’s build an example where we set a context key called "stack" which keeps a history of the function names called over the lifetime of the context. As we pass the context object through a few layers of functions, we’ll append the name of the function to the value of the context key "stack".
Posts
Go channels
Go uses goroutines to execute multiple bits of code at the same time. Channels allow for the aggregation of the results of these concurrent calls after they have finished.
Consider a case where we want to make several GET requests to a server. The server takes some time to process each request, in many cases can handle many simultaneous connections. In a language like Python, we might do the following to make several requests:
Posts
Go closures
Say we need a map to store various versions of a configuration in Go. Here is a simple example of the structure:
envs := map[string]string{ "dev": "1", "prod": "2", } Given this config map, we need to create an additional map that uses the same strings as the keys, but has functions for values. The catch is that the body of each function needs to make use of the value from its corresponding key.
Posts
Creating a Go module
Creating a Go module We’re going to create a CLI tool for sending a message to a channel in Slack using the command line. This post is similar to my earlier post: Creating an Elixir Module. We’ll be using the chat.postMessage Slack API endpoint. Also, make sure you have a Slack API token.
Our CLI syntax will be:
$ ./slack -message 'hello world!' -channel @slackbot First, make sure you have your $GOPATH set properly.