Potential wifi network names

Just saving this list here for later. This time around, we opted for LAN Solo and Pretty fly for a wifi, but I do like the rest too.

So, possible names for future networks:

  • Pretty Fly for a Wifi
  • Troy and Abed in the Modem
  • Tell my Wifi love her
  • LAN Solo
  • Abraham Linksys
  • Silence of the LANs
  • Routers of Rohan
  • Winter-net is coming
  • Wu Tang Lan

golang: Encode/Decode arbitrary JSON

Just a quick post in case I forget how to do this in future. I had a use case for working with reading arbitrary JSON from a file and parsing it using Golang, which meant that the recommended way of using structs wasn’t suitable.


The first thing to do was marshal a custom data structure into being a JSON string using json.Marshal. This was fairly straightforward to do:

cacheContent := map[string]interface{}{
    "foo": "bar",
    "baz": map[string]interface{}{
        "bee": "boo",

str, err := json.Marshal(cacheContent)
if err != nil {
    fmt.Println("Error encoding JSON")

# => {"baz":{"bee":"boo"},"foo":"bar"}


json.Unmarshal was the tough one to work out. As it turns out, all you need to do is define a map of string => interface and then unmarshal into this structure. Go will take care of the rest.

# Using the "str" variable that we created using json.Marshal earlier
var x map[string]interface{}
json.Unmarshal([]byte(str), &x)
fmt.Println("%v", x)
# => %v map[baz:map[bee:boo] foo:bar]

# Using some hand crafted JSON. This could come from a file, web service, anything
str2 := "{\"foo\":[1,2,3]}"

var y map[string]interface{}
json.Unmarshal([]byte(str2), &y)

fmt.Println("%v", y)
# => %v map[foo:[1 2 3]]

Once the data is un-marshalled, you can access it as follows:

fmt.Printf("%v", str["baz"].(map[string]interface{})["bee"})
# => "boo"

As we're un-marshalling into an interface, we need to inform go what data type each key is before we can perform operations on it. This is what the .(map[string]interface{}) does

golang: invalid operation: someVar == “” (mismatched types *string and string)

I was trying to see if a value was empty in a golang script I was writing, when I came across an odd error message:

invalid operation: someVar == "" (mismatched types *string and string)

It turns out that the following code doesn’t return a simple string, but an instance of flag.String

someVar := flag.String("somevar", "", "this is a random flag")

To perform the comparison, you need to use a pointer to it as follows:

if *someVar != "" {
    // Do this