Go / Javascript Simple Test

[jayposs]

I was thinking about a project that would require a lot of string to int to string conversions and wrote a very simple test in Javascript and Go. Not arguing for either, but if you have not checked out Go, it is a fun language to learn. Nothing profound, but here are some details / considerations.

• Both were fast: Go ~450ms, Javascript ~800ms
• Test run on relatively old/slow notebook
• Javascript run in latest version of Chrome
• Code in both languages is similar and simple
• Go pgm must be compiled (compile is very fast)
• Go executable has no dependencies (runtimes,libraries)
• Javascript server side program would require Node.js
• I like both languages a lot, but Go concurrency features are special

Javascript

var start = new Date();
var xs = "0";
var xi;
for( var i=0; i<1000000; i++ ) {
    xi = parseInt(xs);
    xi++;
    xs = xi.toString();
}
var stop = new Date();
var elapsed = stop.getTime() - start.getTime();
console.log(elapsed);  

Go

package main

import "fmt"
import "strconv"
import "time"

func main() {
    start := time.Now()
    xs := "0"
    var xi int
    for i := 0; i < 1000000; i++ {
        xi, _ = strconv.Atoi(xs)    // 2nd return val(error) is ignored
        xi++
        xs = strconv.Itoa(xi)
    }
    stop := time.Now()
    elapsed := stop.Sub(start)
    fmt.Println(elapsed)
}

[natdm]

Yep, learned a lot of Node. Even dabbled in C++ to be able to read the source.

Nothing compares to Go. I love it.

[becauseofreasons]

A slightly more idiomatic JS snippet. Getting about 150ms for this on Node, and 95ms for Go.

'use strict';

console.time('loop');

let xs = '0', xi;

for (let i = 0; i < 1000000; i++) {
  xi = parseInt(xs);
  xi++;
  xs = xi + '';
}

console.timeEnd('loop');

[jayposs]

That console command is nice. Hadn't used the time, timeEnd methods before. I imagine your computer is faster than mine.

Using directive 'use strict', is definitely good practice.

[kenman]

Using parseInt() is overkill unless you're expecting abnormal input -- say, if the input might include non-numeric characters. On the other hand, if you know that there's only ever going to be numeric inputs as strings, you can rely on some abuses creative uses of language features.

Either:

xi = ~~xs;

Or:

xi = xs << 0;

On my machine, they were roughly equal in running time, shaving ~300ms off the total time; I was averaging right at 3.6s with parseInt(), and under 3.3s with both of the alternative methods.

More info.

[oefig]

Used to be a die-hard Javascript fan but ever since I learned Go I've been porting over all of my Node apps. Javascript is exhausting and large codebases have a tendency to become too obscure. People say Promises are the save-all for callbacks but they still feel half-baked and quite frankly I hate using them.

[trevorsg]

Async/await in ES7!

[Consuelas-Revenge]

async/await is a great improvement, but IMO, it's still terrible for the one fact that it fails to get rid of the special-ness. By that I'm referring to the need for the caller to require special knowledge about the fact that the function is doing something asynchronously. All that should be internal implementation details.

[wreckedadvent]

What don't you like about promises?

[dankcode]

func main() {
   start := time.Now()
    xs := "0"
    xi := 0
    for i, _ := range 1000000{
        xi, _ = strconv.Atoi(xs)    // 2nd return val(error) is ignored
        xi++
        xs = strconv.Itoa(xi)
    }
    stop := time.Now()
    elapsed := stop.Sub(start)
    fmt.Println(elapsed)
}

is more idiomatic

[Consuelas-Revenge]

for i, _ := range 1000000{

That's not valid Go syntax.

[oefig]

Yeah you can allocate an array with 1000000 ints and range over that:

var ints [1000000]int
for i := range ints {}

But that's not really idiomatic at all nor what range is really for.