Some days ago ago Apple released Swift as open source language with instructions for Ubuntu Linux 15.10. So I decided to do a couple of simple benchmarks just to test some basic general purpose things like cpu, functions, read/write and not sequential access to arrays, concurrent parallel execution where possibile.
UPDATE: Here is the source code, somebody asked for it, all the tests look almost the same in all languages. I've also add gccgo as compiler with "-O" optimization
It generates 2 growable arrays with incremented numbers, then it returns the sum of some of their elements.
Unoptimized Fibonacci sequence, a recursive function.
Why this comparison?
Because 3 programming languages are:
- Modern user-friendly typed languages
- The syntax is very similar (at least for basic scenarios)
- To see if the performance benefits are worth and evident or not
CPU: Intel Core 2 Duo E8400 @3.00Ghz
OS: Ubuntu 15.10, Kernel Linux 4.2.0-19-generic
- Golang: go version go1.5.2 linux/amd64,gccgo (Ubuntu 5.2.1-22ubuntu2) 5.2.1 20151010
- NodeJS: Node v5.1.1
- Swiftlang: Swift version 2.2-dev
- Rustlang: rustc 1.5.0-beta.5 (b716bc93c 2015-12-02)
In all test is measured the total execution time with the
In the first test the winner is Rust, both Rust and Swift get a noticeable boost if the binary is compiled with "-O" flag.
Here the fastest is Swift, then Rust. It is a bit weird because they both compile in LLVM.
All these new user-friendly typed languages have a very similar syntax. In Rust you have much more control in your code and some conversions aren't done automatically, I had to specify
i as usize to use that integer as index.
In Go you have a specific operator
<-to deal with channels.
Concurrency / Parallelism
I tried to run another benchmark, the sum of fib(45) + fib(43).
- Golang: to enable all the cores, you have to put in your code
runtime.GOMAXPROCS(num of cores you want to use)
- Rust: there are several ways for different use cases, I used the 3rd part lib async-await, the result is correct
but it seems the computation on one core slow down even if the task isn't finished yet. Upgrading from beta to Rust 1.5 stable I no longer have this issue.
- NodeJS: it is single thread, you can use all your cores running multiple instances of your code.
- Swift: It should be possible to use libdispatch on Linux but I didn't tried it
Use cases and opinions
General use case: choose the one you like more, it is mostly a syntax and ecosystem issue.
Go: mature, concurrency, backend, micro services, CLI utilities
Rust: low level control, safety, concurrency, speed, functional features
Swift: IOS native & OSX built-in, functional features
I didn't compare these languages to dynamic languages like ruby or python because there are already a lot of comparisons with them.