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
