Koazee vs Go-Funk vs Go-Linq

The purpose of this article is providing a benchmark comparison between Koazee and two of the most well-known Golang frameworks to work with arrays: Go-Funk and Go-Linq.

Sources

• Koazee: https://github.com/wesovilabs/koazee
• Go-Linq: https://github.com/ahmetb/go-linq
• Go-Funk: https://github.com/thoas/go-funk

The repository used to create the benchmark comparison can be found on my Github organization, https://github.com/wesovilabs/koazee-comparison

Comparison

The benchmark tests can be run from your own computer, code can be download from here

For this comparison I’ve been focused on how the 3 frameworks deals with arrays of primitive types.

The below graph shows how is the frameworks performance for each test:

The axis-y shows the ns/op per operation and axis-x the different tests. As we can observe, the performance in Koazee is much better for all the scenarios.

The tests are described below:

• Sum: Given an array with 5000 random numbers we must find the sum of all its elements.

Koazee: 18014 ns/op GoLinq: 239511 ns/op GoFunk: 2096351 ns/op

• Duplicate: Given an array with 5000 random numbers we must return another array where each element has been multiplied by 2

Koazee: 28762 ns/op GoLinq: 456650 ns/op GoFunk: p1816872 ns/op

• Reverse: Given an array with 5000 random numbers we must reverse the sequences of numbers

Koazee: 21462 ns/op GoFunk: 167916 ns/op GoLinq: 503982 ns/op

Sort: Given an array with 5000 random numbers we must return an array with the elements ascending ordered.

Koazee: 570380 GoLinq: 1882618 ns/op

(*)Probably, It’s my fault but I didn’t find a way to perform this action in GoFunk

Filter: Given an array with 5000 random we will return an array with only the odd elements.

Koazee: 111382 ns/op GoLinq: 326412 ns/op GoFunk: 1748583 ns/op

Contains: Given an array with 5000 random numbers we must return if the element in the last position is found or not

Koazee: 3607 ns/op GoFunk: 248290 ns/op GoLinq: 107764 ns/op

Multiple operations: Given an array with 5000 random strings, we need to perform the below operations:

• Sort the strings ascending
• Reverse the sequence of strings
• Filter the array and discard those words whose len is not 4.
• Convert array of string into an array of int, where the new elements will be the length of the word. (Obviously all the elements in the new array will be 4 after the applied filter in the previous step)
• Sum all the elements

Koazee: 2447864 ns/op GoLinq: 3096456 ns/op

(*) GoFunk doesn’t provide a way to concatenate operations

Conclussions

• Koazee is the youngest, and the set of provided operations is poor. Basically It’s only one month since I started coding it and most of time I’ve been focused on improving performance.
• It’s clear that performance in Koazee is much better.

Implement new operations is easy, doing better than others is the most complicated part

• Koazee is the only one that provides us with the error in case of something didn’t work as expected, make it the safest library.
• GoFunk doesn’t provide a friendly way to concatenate operations as Koazee or GoLinq do.
• Koazee is the only that doesn’t force you to cast function inputs while you’re defining your operations.

For future release Koazee v0.0.3 I would like to provide a richer set of operations over arrays. but always, being focused on providing the best performance.

If you like the project, the article or just think this project deserves being supported, I would really appreciate if you share it on your networks , tweet the article or star the repository in Github