go

The Changelog Podcast - Interview with Rob Pike

Sun, 16 May 2010 15:55:37 -0400

The Changelog Podcast - Interview with Rob Pike

Why Google's Go is a Bore

Tue, 11 May 2010 18:43:49 -0400

Why Google's Go is a Bore

Asynchronous Go API idioms

Tue, 11 May 2010 18:42:26 -0400

Asynchronous Go API idioms

Rob Pike on Go

Tue, 11 May 2010 18:41:05 -0400

Rob Pike on Go

Hacker News: An Introduction to Google's Go Programming Language

Tue, 13 Apr 2010 22:51:25 -0400

Hacker News: An Introduction to Google's Go Programming Language

release.2010-03-30

Wed, 31 Mar 2010 01:05:23 -0400

release.2010-03-30:

Maps now return a default value! Not really sure of the other features yet or what they mean, need to look into panic and recover more though.

Broken abstractions in Go

Tue, 30 Mar 2010 09:04:40 -0400

Broken abstractions in Go

Rendering distance fields using the Go-language

Mon, 29 Mar 2010 13:38:30 -0400

Rendering distance fields using the Go-language

Proposal for an exception-like mechanism

Thu, 25 Mar 2010 15:35:38 -0400

Proposal for an exception-like mechanism

autodetect go.vim highlighting

Wed, 24 Mar 2010 16:07:28 -0400

Instead of constantly having to hit :setf go when editing your Go files in vim, just drop this into ~/.vim/ftdetect/go.vim:

autocmd BufNewFile,BufReadPost *.go set filetype=go

go.vim : Syntax file for the Go programming language

Mon, 22 Mar 2010 18:31:52 -0400

go.vim : Syntax file for the Go programming language

Installing Go on Ubuntu

Mon, 22 Mar 2010 18:15:20 -0400

Installing Go on Ubuntu

regexp.MatchString

Mon, 15 Mar 2010 19:03:32 -0400

Everyone loves Regular Expressions, right? Instead of writing an annoying parser for our first assignment, expr, it was definitely easier to just use Go’s built in regexp package. The easiest way is just to use regexp.MatchString:

matched, error := regexp.MatchString("[0-9]+", "1337")

This returns a boolean, matched, and an os.Error in the second variable. This whole multiple return thing is pretty crazy. So using it in an if statement is a bit clunky if we want to do it in one line. Here’s a short example:

package main

import (
	"os"
	"regexp"
	"fmt"
)

func main() {
  if len(os.Args) == 1 {
    fmt.Println("Usage: regexp [string]")
    os.Exit(1)
  } else if m, _ := regexp.MatchString("^[0-9]+$", os.Args[1]); m {
    fmt.Println("Totally numbers")
  } else {
    fmt.Println("Totally not numbers")
  }
}

% ./bin/regexp 
Usage: regexp [string]

% ./bin/regexp 1234
Totally numbers

% ./bin/regexp abcd
Totally not numbers

% ./bin/regexp 12zx34
Totally not numbers

I suppose it could be two lines, but why bother? Check out the package documentation for more, and the code is here on GitHub.

git precommit hook for gofmt

Wed, 10 Mar 2010 18:37:00 -0500

It’s no surprise I like Ruby, and gofmt is a great idea I wish Ruby could enforce. Instead of forgetting to run it constantly, let’s have git run it. In your .git/hooks/pre-commit:

#!/usr/bin/env ruby
Dir["**/*.go"].each do |go|
  if File.basename(go) !~ /^_/
    puts "gofmt #{go}"
    system("gofmt -w=true #{go} && git add #{go}")
  end
end

Make sure you run chmod a+x on that hook too. Also, this will mess up any incremental commits with git add -p, but you can use git commit --no-verify to bypass the hooks if you need to.

flag

Wed, 10 Mar 2010 17:22:00 -0500

Checking out the flag package, Go’s built in command line argument parser. Here’s a simple example:

// flag.go
package main

import (
  "flag"
  "fmt"
)

var code *int = flag.Int("areacode", 716, "give me your codes")

func main() {
  fmt.Printf("Testing out flags!\n");
  flag.Parse();
  fmt.Println("areacode has value ", *code);
}

# Makefile
include $(GOROOT)/src/Make.$(GOARCH)
 
TARG=flag
GOFILES=\
        flag.go
 
include $(GOROOT)/src/Make.cmd

Compile and run away:

% make
/Users/qrush/Progs/8g -o _go_.8 flag.go
/Users/qrush/Progs/8l -o flag _go_.8

% ./flag
Testing out flags!
areacode has value  716

% ./flag -areacode=585
Testing out flags!
areacode has value  585

Mindblowing, I know. Also cool: flag.PrintDefaults() gives a nice printout of the command line arguments with default values.

gofmt

Wed, 10 Mar 2010 16:26:32 -0500

From the FAQ:

…the program gofmt is a pretty-printer whose purpose is to enforce layout rules; it replaces the usual compendium of do’s and don’ts that allows interpretation. All the Go code in the repository has been run through gofmt.

usage: gofmt [flags] [path ...]
  -tabwidth=8: tab width
  -trace=false: print parse trace
  -r="": rewrite rule (e.g., 'α[β:len(α)] -> α[β:]')
  -debug=false: print debugging information
  -tabindent=true: indent with tabs independent of -spaces
  -l=false: list files whose formatting differs from gofmt's
  -w=false: write result to (source) file instead of stdout
  -spaces=true: align with spaces instead of tabs
  -comments=true: print comments

go-repl

Wed, 10 Mar 2010 15:16:00 -0500

go-repl:

Took some hacking to get working since recently in go the way to convert a String into a series of Bytes changed:

There is one language change: the ability to convert a string to
[]byte or []int.  This deprecates the strings.Bytes and strings.Runes
functions. You can convert your existing sources using these gofmt
commands:

gofmt -r 'strings.Bytes(x) -> []byte(x)' -w file-or-directory-list
gofmt -r 'strings.Runes(x) -> []int(x)' -w file-or-directory-list

After running these you might need to delete unused imports of the
"strings" package.

Fixed now and works on my machine™, granted you put semicolons at the end of lines in the REPL.

hg log -r 0:4

Wed, 10 Mar 2010 14:22:40 -0500

changeset:   0:f6182e5abf5e
user:        Brian Kernighan <bwk>
date:        Tue Jul 18 19:05:45 1972 -0500
summary:     hello, world

changeset:   1:b66d0bf8da3e
user:        Brian Kernighan <bwk>
date:        Sun Jan 20 01:02:03 1974 -0400
summary:     convert to C

changeset:   2:ac3363d7e788
user:        Brian Kernighan <research!bwk>
date:        Fri Apr 01 02:02:04 1988 -0500
summary:     convert to Draft-Proposed ANSI C

changeset:   3:172d32922e72
user:        Brian Kernighan <bwk@research.att.com>
date:        Fri Apr 01 02:03:04 1988 -0500
summary:     last-minute fix: convert to ANSI C

changeset:   4:4e9a5b095532
user:        Robert Griesemer <gri@golang.org>
date:        Sun Mar 02 20:47:34 2008 -0800
summary:     Go spec starting point.

Installing Go on OSX 10.5

Mon, 08 Mar 2010 18:58:00 -0500

Heavily inspired by this blog post. With MacPorts installed:

sudo port install python easy_install
sudo easy_install -U mercurial

In your .zshrc:

export GOROOT=[path to where you want the language installed]
export GOOS=darwin
export GOARCH=386
export GOBIN=[path to where you store personal bin files]

Run:

source .zshrc
hg clone -r release https://go.googlecode.com/hg/ $GOROOT
cd $GOROOT/src
./all.bash

That should stick some binaries into your GOBIN directory. Create a helloworld.go:

package main

import fmt "fmt"

func main() {
  fmt.Printf("HELLO WORLD");
}

Then run…

$ 8g helloworld.go
$ 8l helloworld.8
$ ./8.out
HELLO WORLD