[Concurrency] Goroutines

func main() {
  // A "channel"
  ch := make(chan string)

  // Start concurrent routines
  go push("Moe", ch)
  go push("Larry", ch)
  go push("Curly", ch)

  // Read 3 results
  // (Since our goroutines are concurrent,
  // the order isn't guaranteed!)
  fmt.Println(<-ch, <-ch, <-ch)
func push(name string, ch chan string) {
  msg := "Hey, " + name
  ch <- msg

Channels are concurrency-safe communication objects, used in goroutines.

See: Goroutines, Channels

[Concurrency] WaitGroup

import "sync"

func main() {
  var wg sync.WaitGroup

  for _, item := range itemList {
    // Increment WaitGroup Counter
    go doOperation(item)
  // Wait for goroutines to finish

func doOperation(item string) {
  defer wg.Done()
  // do operation on item
  // ...

A WaitGroup waits for a collection of goroutines to finish. The main goroutine calls Add to set the number of goroutines to wait for. The goroutine calls wg.Done() when it finishes. See: WaitGroup

[Concurrency] Buffered channels

ch := make(chan int, 2)
ch <- 1
ch <- 2
ch <- 3
// fatal error:
// all goroutines are asleep - deadlock!

Buffered channels limit the amount of messages it can keep.

See: Buffered channels

[Concurrency] Closing channels

Closes a channel

ch <- 1
ch <- 2
ch <- 3

Iterates across a channel until its closed

for i := range ch {

Closed if ok == false

v, ok := <- ch

See: Range and close

[Packages] Exporting names

func Hello () {

Exported names begin with capital letters.

See: Exported names

[Packages] Packages

package hello

Every package file has to start with package.

[Packages] Importing

import "fmt"
import "math/rand"
import (
  "fmt"        // gives fmt.Println
  "math/rand"  // gives rand.Intn

Both are the same.

See: Importing

[Packages] Aliases

import r "math/rand"

[Structs] Pointers to structs

v := &Vertex{1, 2}
v.X = 2

Doing v.X is the same as doing (*v).X, when v is a pointer.

[Structs] Defining

type Vertex struct {
  X int
  Y int
func main() {
  v := Vertex{1, 2}
  v.X = 4
  fmt.Println(v.X, v.Y)

See: Structs

[Structs] Literals

v := Vertex{X: 1, Y: 2}
// Field names can be omitted
v := Vertex{1, 2}
// Y is implicit
v := Vertex{X: 1}

You can also put field names.

[Error control] Deferring functions

func main() {
  defer func() {

Lambdas are better suited for defer blocks.

func main() {
  var d = int64(0)
  defer func(d *int64) {
    fmt.Printf("& %v Unix Sec\n", *d)
  fmt.Print("Done ")
  d = time.Now().Unix()

The defer func uses current value of d, unless we use a pointer to get final value at end of main.

[Error control] Defer

func main() {
  defer fmt.Println("Done")

Defers running a function until the surrounding function returns. The arguments are evaluated immediately, but the function call is not ran until later.

See: Defer, panic and recover

[Interfaces] Interface example

func main() {
  var r Shape = Rectangle{Length: 3, Width: 4}
  fmt.Printf("Type of r: %T, Area: %v, Perimeter: %v.", r, r.Area(), r.Perimeter())

[Interfaces] Struct

type Rectangle struct {
  Length, Width float64

Struct Rectangle implicitly implements interface Shape by implementing all of its methods.

[Interfaces] Methods

func (r Rectangle) Area() float64 {
  return r.Length * r.Width

func (r Rectangle) Perimeter() float64 {
  return 2 * (r.Length + r.Width)

The methods defined in Shape are implemented in Rectangle.

[Methods] Mutation

func (v *Vertex) Scale(f float64) {
  v.X = v.X * f
  v.Y = v.Y * f
v := Vertex{6, 12}
// `v` is updated

By defining your receiver as a pointer (*Vertex), you can do mutations.

See: Pointer receivers

[Methods] Receivers

type Vertex struct {
  X, Y float64
func (v Vertex) Abs() float64 {
  return math.Sqrt(v.X * v.X + v.Y * v.Y)
v := Vertex{1, 2}

There are no classes, but you can define functions with receivers.

See: Methods

[Interfaces] A basic interface

type Shape interface {
  Area() float64
  Perimeter() float64

[Functions] Named return values

func split(sum int) (x, y int) {
  x = sum * 4 / 9
  y = sum - x

By defining the return value names in the signature, a return (no args) will return variables with those names.

See: Named return values

[Functions] Lambdas

myfunc := func() bool {
  return x > 10000

{: data-line="1"}

Functions are first class objects.

[Functions] Multiple return types

a, b := getMessage()
func getMessage() (a string, b string) {
  return "Hello", "World"

{: data-line="2"}

[Flow control] Switch

switch day {
  case "sunday":
    // cases don't "fall through" by default!

  case "saturday":


See: Switch

[Flow control] While loop

n := 0
x := 42
for n != x {
  n := guess()

See: Go's "while"

[Flow control] For loop

for count := 0; count <= 10; count++ {
  fmt.Println("My counter is at", count)

See: For loops

[Flow control] For-Range loop

entry := []string{"Jack","John","Jones"}
for i, val := range entry {
  fmt.Printf("At position %d, the character %s is present\n", i, val)

See: For-Range loops

[References] Other links

[References] Official resources

Files Embedding

Go programs can embed static files using the "embed" package as follows:

package main

import (

// content holds the static content (2 files) or the web server.
//go:embed a.txt b.txt
var content embed.FS

func main() {
    http.Handle("/", http.FileServer(http.FS(content)))
    log.Fatal(http.ListenAndServe(":8080", nil))

HTTP Server

package main

import (

// define a type for the response
type Hello struct{}

// let that type implement the ServeHTTP method (defined in interface http.Handler)
func (h Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello!")

func main() {
    var h Hello
    http.ListenAndServe("localhost:4000", h)

// Here's the method signature of http.ServeHTTP:
// type Handler interface {
//     ServeHTTP(w http.ResponseWriter, r *http.Request)
// }


dplyr cheat sheet is a quick reference for dplyr that is a grammar of data manipulation, providing a consistent set of verbs that help you solve the most common data manipulation challenges.


A regular expression is a sequence of characters that specifies a search pattern.


PySpark is an interface for Apache Spark in Python. It not only allows you to write Spark applications using Python APIs


Go is a statically typed, compiled programming language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson.


Watchman exists to watch files and record when they change. It can also trigger actions (such as rebuilding assets) when matching files change.


Rollup Rollup is a module bundler for JavaScript which compiles small pieces of code into something larger and more complex, such as a library or application.


Bluebird is a fully-featured Promise library for JavaScript. The strongest feature of Bluebird is that it allows you to "promisify" other Node modules in order to use them asynchronously. Promisify is a concept applied to callback functions.


Flow is a static type checker for your JavaScript code. It does a lot of work to make you more productive. Making you code faster, smarter, more confidently, and to a bigger scale.

Node.Js Api

Node.js® is a JavaScript runtime built on Chrome's V8 JavaScript engine.

C Preprocessor

Quick reference for the C macro preprocessor, which can be used independent of C/C++.


Sass is a preprocessor scripting language that is interpreted or compiled into Cascading Style Sheets. SassScript is the scripting language itself. Sass consists of two syntaxes.


Active Admin is a Ruby on Rails plugin for generating administration style interfaces. It abstracts common business application patterns to make it simple for developers to implement beautiful and elegant interfaces with very little effort.


The Fetch standard defines requests, responses, and the process that binds them: fetching.


$ http POST http://example.com name="John" Host:example.com — JSON, cookies, files, auth, and other httpie examples.


RSpec is a computer domain-specific language testing tool written in the programming language Ruby to test Ruby code. It is a behavior-driven development framework which is extensively used in production applications.


Sauce Labs allows users to run tests in the cloud on more than 700 different browser platforms, operating systems, and device combinations.


Jasmine is a behavior-driven development framework for testing JavaScript code.


Sequelize is a promise-based Node.js ORM for Postgres, MySQL, MariaDB, SQLite and Microsoft SQL Server.


Ubuntu is a Linux distribution based on Debian and composed mostly of free and open-source software. Ubuntu is officially released in three editions: Desktop, Server, and Core for Internet of things devices and robots.

Rails Models

Ruby on Rails, or Rails, is a server-side web application framework written in Ruby under the MIT License. Rail is a model–view–controller framework, providing default structures for a database, a web service, and web pages.

Git Log

Git is software for tracking changes in any set of files, usually used for coordinating work among programmers collaboratively developing source code during software development.


Ruby on Rails, or Rails, is a server-side web application framework written in Ruby under the MIT License. Rails is a model–view–controller framework, providing default structures for a database, a web service, and web pages.

Ansible Examples

Ansible is an open-source software provisioning, configuration management, and application-deployment tool enabling infrastructure as code.

Bolt Quickstart

A quick guide to getting started writing Bolt tasks


RSpec Rails defines ten different types of specs for testing different parts of a typical Rails application.


rsync is a utility for efficiently transferring and synchronizing files between a computer and an external hard drive and across networked computers by comparing the modification times and sizes of files.

Ledger Cli

Ledger is a command-line based double-entry bookkeeping application. Accounting data is stored in a plain text file, using a simple format, which the users prepare themselves using other tools.


Homebrew is a free and open-source software package management system that simplifies the installation of software on Apple's operating system macOS as well as Linux.


Bundler provides a consistent environment for Ruby projects by tracking and installing the exact gems and versions that are needed.