Ernest Micklei's Blog

A solution to an exercise from Programming Erlang which I explained here

This short (2 min) video was created using a simple interactive Ubanita script that translated touch events into Triangle generation. See below the interesting part of that program. For each touchMove event, a random colored Triangle sprite is added. For each touchEnd event, such Triangles are created with a outwards radial velocity. // touchMove is called when the game detects a movement in a touch function touchMove(event) { dust.x = event.

Kimtato is the name of a simple interactive demo that runs on the Ubanita platform. It is a playground of physical objects which are created by players using touch gestures on the controller. Once created, the objects can be pushed around using the two-finger gesture, we call edge input mode. (EM: 2020-05-12: somehow this movie got taken down; don't know why) The following will discuss the making of this demo using the Ubanita Script API.

Go package forest was created to simplify the code needed to write real tests of a REST api. Such tests need to setup Http Requests, send them and inspect Http Responses. The Go standard library has all that is needed to achieve this flow but the required amount of code, especially the error handling, makes tests harder to read and longer to write. Testing github Let's create a few tests that examine the response of the public github API call.

Artreyu is an open-source command line tool for software build pipelines that need to create artifacts which are composed of multiple versioned build parts. The design of this tool is inspired by the Apache Maven project which provides assembly support for Java projects. I created Artreyu to support a project that delivers compositions of many non-Java artifacts of which some are operating system dependent. Artreyu works with a repository to archive, fetch and assemble artifacts.

ernest [dot] micklei [at] gmail [dot] com

Today, I needed to keep track of the linenumber while scanning table driven tests. The standard Go bufio.Scanner does not provide such information. Fortunately, in Go you can create your own by embedding the standard type and overriding the right function. That’s it. import ( "bufio" "io" ) type linescanner struct { *bufio.Scanner line int } func newScanner(reader io.Reader) *linescanner { return &linescanner{bufio.NewScanner(reader), 0} } func (l *linescanner) Scan() bool { ok := l.

I needed a simple solution to notify components about changes in some global settings. In my Java days, I have been using the Guava Eventbus to solve similar problems, so I decided to cook something that does the basics. From Guava: “The EventBus allows publish-subscribe-style communication between components requiring the components to explicitly register with one another (and thus be aware of each other).” The Java implementation uses annotations to register components and subscribe its methods to event types.

package main import "fmt" type intSlice []int func (i intSlice) collect(block func(i int) int) intSlice { r := make(intSlice, len(i)) for j, v := range i { r[j] = block(v) } return r } func main() { numbers := intSlice{1, 2, 3} squared := func(i int) int { return i * i } fmt.Printf("%v", numbers.collect(squared)) } Try it. Implementations of select,inject,detect are left as an excercise for the reader.

Today, I was playing with Otto and hacked together a small command-line-interface program in Go. package main import ( "bufio" "fmt" "os" "strings" "github.com/robertkrimen/otto" ) var Otto = otto.New() func main() { fmt.Println("otto\n") loop() } func dispatch(entry string) string { if len(entry) == 0 { return entry } value, err := Otto.Run(entry) if err != nil { return err.Error() } else { return fmt.Sprintf("%v", value) } } func loop() { for { fmt.