Adventure in Go

From A Node.js Developer

This is Me

Soares Chen

@soareschen

JavaScript

3 years experience 

Quiver.js

  • Next-Generation web framework
  • ES6
  • Declarative components
  • Functional programming in steroid using object-oriented programming

http://quiverjs.org

Go

2 months experience

C/C++

6+ years of experience

Many More Languages

Over last 12 years

Design of Programming Languages

I care about

over

hypes, horror or success stories

What You Can Expect From Me

  • Objective but opinionated comparison on Go
  • Good & bad parts
  • Best practices from other languages

Tell Me I am Wrong

I am here to learn, just as you are

Go is a

weird language

First Impression

Go is a static typed language

Go is a dynamic typed language with static typed compilable primitives

Good part: Struct

  • Similar to C struct
  • No inheritance hell
type Character struct {
  Name string
  HP, MP, Level int
}

Bad Part: Struct Initialization

  • Anyone can initialize new struct
  • Ugly "&" character for pointer initialize
var swordsman *Character

swordsman = &Character{
  Name: "dark_knight",
  HP: 100,
  MP: 30,
  Level: 4,
}

Bad Part: Nullable Defaults

  • All fields are optional
  • Pointer fields can be null
swordsman := &Character{
  HP: 100,
  Level: 4,
}

swordsman.Name // ""
swordsman.MP // 0

So Go does the static type checking for you..

But you have to do all null-checking yourself?

The Problem

Go uses structs for two kind of purposes

  • Records
  • State Management
type Person struct {
  Name string
  Age int
  Company *Company
}

Best Practice

Records as plain structs

  • Plain structs used as records
  • No method - never upgrade to interface
  • Interface implies encapsulation, which public structs lack
type Person struct { ... }

func validatePerson(person *Person) error { ... }
func estimateSalary(person *Person) int { ... }

person := &Person{...}
err := validatePerson(person)
salary := estimateSalary(person)

Best Practice

Use constructor function

  • Never create struct manually
  • Never modify fields directly
var character, monster *Character

swordsman := createCharacter("dark_knight", ...)
swordsman.receiveExperience(15)

Ideally

Use Interface

  • Never create struct manually
  • Enforce attribute constraints
  • getter/setter, etc
struct character { ... }

interface Character {
  GetHP() int
  GetMP() int
  GetLevel() int

  Attack(enemy Character, damage int)
  ReceiveExperience(exp int)
}

Go: the bad part

No getter/setter Interface Methods

  • Can't use interface like a struct with transparent getter
  • Hurts performance
struct character { ... }

// Note: Not possible
interface Character {
  get Name() string
  get HP() int
  get MP() int
  ...
}

swordsman = createCharacter("dark_knight", ...)
swordsman.Name // "dark_knight"

Go: the bad part

Cannot define methods on interfaces

struct character { ... }

interface Character {
  Name() string
  HP() int
  MP() int
}

interface Attacker {
  Attack(enemy Character, damage int)
}

// Note: Not possible
func (c Character) Attack(enemy Character, damage int) {
  ...
}

Go: the good part

Interface Upgrade

  • Can optimize code if object can upgrade to more specialized interface
func saveTheWorld(character Character) {
  superman, ok := character.(Superman)
  if ok {
    ...
  }
}

Go: the bad part

Cannot add new upgrade to Interface

interface Character { ... }
interface Superhero { ... }
interface Villian { ... }

func giveSuperpower(character Character) Character {
  return &characterWithSuperpower{character, ...}
}

func destroyWorld(character Character) {
  villian, ok := character.(Villian)
  if ok { ... }
}

joker := createVillian(...)
superJoker := giveSuperpower(joker)
destroyWorld(superJoker) // Is superJoker still a Villian?

JavaScript ES6

  • Duck-typing
  • Prototype inheritence
  • getter/setter
  • Symbol fields
  • Proxy

Yes if you think Go interface upgrade is cool

Does it matter?

Other Go vs Node

Functional Programmnig

func createCounter() func() int {
  counter := 0

  return func() int {
    return counter++
  }
}
var createCounter = function() {
  var counter = 0

  return function() {
    return counter++
  }
}

Error Handling

  • I want one liner in Go
  • if(err) return err
func manageUser() error {
  db, err := connectDatabase(...)
  if err != nil {
    return err
  }

  user, err := getUser(db, ...)
  if err != nil {
    return err
  }

  ...
}
var manageUser = function(callback) {
  connectDatabase(..., function(err, db) {
    if(err) return callback(err)

    getUser(db, ..., function(err, user) {
      if(err) return callback(err)

      ...
    }
  }
}

Http Handler

  • Same middleware architecture
func (ctx *MyHandler) ServeHTTP(
  w http.ResponseWriter, req *http.Request, next http.HandlerFunc) 
{
  ...
}
var myHandler = function(request, response, next) {
  ...
}

Package Naming

  • Go, you have copied it wrongly
  • Naming hell
import (
  user "myapp/user"
  post "myapp/post"
}

u := &user.User{...}

p := &post.Post{
  User: u,
  ...
}
var user = require('myapp/user')
var post = require('myapp/post')

var u = new user.User(...)

var p = new post.Post({
  user: u,
  ...
})

Naming Workaround

  • Use "Lib" to postfix packages
import (
  userLib "myapp/user"
}

user := &userLib.User{...}
var userLib = require('myapp/user')

var user = new userLib.User(...)

ES6 solves the pain shared in both Go and Node

  • Promises
  • Modules

ES5 < Go < ES6

Go or JavaScript?

Node

io.js

Still, use the right tool for the right job

  • ES6 still in development, Go is stable and mature
  • Go HTTP libraries are as good as Node Express, if not better
  • Many advantages/disadvantages as a compiled language

If only JavaScript programmers can write their code more like Go

And Go programmers can write their code more like JavaScript

The world would be a better place

Made with Slides.com