GopherJS

Standard packages

Fully supported: 110

Partially supported: 12

• net/http
• os and syscall supported on Node.js

Not supported: 21

• unsafe

Goroutines are supported

• Local variables are stored in closures
• When a something blocks, the call stack is unwound
• When a goroutine is resumed, its call stack and closures are restored

Access the JavaScript world

package main

import "github.com/gopherjs/gopherjs/js"

var doc = js.Global.Get("document")

func main() {
    div := doc.Call("createElement", "div")
    div.Set("innerText", "hello world")

    doc.Get("body").Call("appendChild", div)
}

Export objects to the JavaScript world, part 1

const MyString = "hello world"

func MyApplyFunc(callable *js.Object, arg string) {
    if callable != js.Undefined {
        callable.Invoke(arg)
    }
}

func main() {
    js.Global.Get("window").Set("MyStuff", map[string]interface{}{
        "MY_STRING":   MyString,
        "myApplyFunc": MyApplyFunc,
    })
}

> MyStuff.myApplyFunc(someUnaryFunction, "asdf")

Export objects to the JavaScript world, part 2

type ValueThing struct {
    Foo int
    Bar string
    Baz []uint16
}

func NewValueThing() *ValueThing {
    return &ValueThing{}
}

func (t *ValueThing) GetSomething() int {
    return 42
}

> t = examples.NewValueThing()
> t
Object {Foo: 0, Bar: "", Baz: Array[0]}
> t.GetSomething()
Uncaught TypeError: t.GetSomething is not a function

Export objects to the JavaScript world, part 3

type ActiveThing struct {
    Foo int
    Bar string
    Baz []uint16
}

func NewActiveThing() *js.Object {
    return js.MakeWrapper(&ActiveThing{})
}

func (t *ActiveThing) GetSomething() int {
    return 42
}

> t = examples.NewActiveThing()
> t
Object {internal stuff only}
> t.GetSomething()
42

Goroutine gotcha

Doesn't work:

import "net/http"

func MyExportedFunc1(url string) {
    r, _ := http.Get(url)          // blocking call
    println(r)
}

Works:

import "net/http"

func MyExportedFunc2(url string) {
    go func() {
        r, _ := http.Get(url)      // blocking call
        println(r)
    }()
}

GOARCH is "js"

// +build js

import "github.com/gopherjs/gopherjs/js"

func Display(message string) {
    js.Global.Get("console").Call("log", message)
}

// +build !js

import "fmt"
import "os"

func Display(message string) {
    fmt.Fprintln(os.Stderr, message)
}

File sizes

Empty main function:

• 50 KB minified
• 12 KB minified and gzipped

Import the sort package:

• 51 KB minified
• 12 KB minified and gzipped

Import the fmt package:

• 392 KB
• 77 KB gzipped

NinchatClient

• Low-level API client implemented in GopherJS
• Robust I/O state machine thanks to goroutines
• Avoid bloat by using the browser's APIs directly
• Supports IE8+ with shims (and stubs for typed array types)
• Same code base supports also native Go
• https://github.com/ninchat/ninchat-go is an importable Go package
• https://github.com/ninchat/ninchat-js is the main package

NinchatClient cont'd

Code base:

• 65% common code
• 22% GopherJS wrapper code
• 13% native Go wrapper code (for custom abstractions)

File size:

• 157 KB minified
• 30 KB minified and gzipped

Estimated file size without direct browser API calls:

• 3 MB minified
• 600 KB minified and gzipped

Performance

Ninchat profiling:

• Object conversion between JS and Go worlds takes time
• UI framework etc. take up most of the time anyway

Internet says:

• "Performance is quite good in most cases"
• Microbenchmarks may be 1000x slower than native Go
• ...or they may be faster, thanks to V8

Debugging

• Supports source maps

Conclusion

• Don't use anything that imports the fmt package (etc.) if file size matters
• Mapping complicated Go APIs to JavaScript is complicated
• As for running Go code in the browser: it just works!
• Goroutines, channels and static typing bring their benefits if a reasonably self-contained part of your application is implemented in Go

Thank you