db-benchmark VS julia

Compare db-benchmark vs julia and see what are their differences.


reproducible benchmark of database-like ops (by h2oai)
Our great sponsors
  • OPS - Build and Run Open Source Unikernels
  • Scout APM - Less time debugging, more time building
  • SonarLint - Deliver Cleaner and Safer Code - Right in Your IDE of Choice!
db-benchmark julia
40 150
201 37,981
7.0% 1.9%
7.8 9.9
23 days ago 2 days ago
R Julia
Mozilla Public License 2.0 MIT License
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.


Posts with mentions or reviews of db-benchmark. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2021-12-22.


Posts with mentions or reviews of julia. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2022-01-20.
  • Why does Julia need so much RAM?
    1 project | reddit.com/r/Julia | 25 Jan 2022
    The ram Julia uses at startup comes mainly from 3 places. 1. OpenBLAS buffers (this is the biggest by a bunch). Julia allocates a bunch of memory to make matrix multiplication faster. It would be possible (and smart) to deffer this allocation until the user asks to do a large matrix multiplication, (this would be a great PR). 2. LLVM. Julia keeps a compiler in ram so that it can generate code for new method instances. As of 1.8, https://github.com/JuliaLang/julia/pull/41936 will allow Julia to have a much lower memory footprint if you have a sysimage and don't need to define new methods 3. Docs. Julia stores all the docs for every function in ram so you can look up help strings. This could be loaded more lazily.
  • The Must-Have Neovim Plugins for Julia
    12 projects | dev.to | 20 Jan 2022
    Julia is a high-level, high-performance and dynamic programming language that is designed to be fast and easy to write like a scripting language. Over the years, the language has gained some popularity, mostly data science and the academe. Many of its features is well suited for numerical analysis and computational science. If you want to try Julia, you can download the release version at https://julialang.org. For platform specific instructions, you can go here https://julialang.org/downloads/platform
  • Julia vs. Python 3 – Which programs are fastest?
    1 project | news.ycombinator.com | 17 Jan 2022
    Julia v1.8 will have a pretty big change in terms of the runtime, in that the runtime will no longer necessarily need to have LLVM attached to it: https://github.com/JuliaLang/julia/pull/41936
  • Things I learnt about Julia during Advent of Code
    1 project | news.ycombinator.com | 14 Jan 2022
    The function reduce(hcat,n) should be faster as there is optimized implementation of it:


    This feature was discussed here:

  • State of Machine Learning in Julia
    3 projects | news.ycombinator.com | 12 Jan 2022
    Ask and you shall receive:https://github.com/JuliaLang/julia/pull/41936

    That giant runtime enables all sorts of features that are used by unparalleled julia packages.

    Soon TM you'll be able to emit runtime free static binaries if you don't need the dynamism. In fact, that's what the GPU compiler does already

    3 projects | news.ycombinator.com | 12 Jan 2022
    His point is that he's not trying to write generic code. In that case, Julia should act like an interactive Fortran, which would be nice, but then it needs to fix latency and binary building for the "this is pure Float64 and we know it" case. The only gain one really gets here is that type inference means you can write a bit simpler code, but that's not a huge win. That's a valid criticism that should hopefully be addressed soon, with https://github.com/JuliaLang/julia/pull/41936 being one of the biggest steps to getting there, along with the more precompilation stuff.
  • Why Fortran is easy to learn
    19 projects | news.ycombinator.com | 7 Jan 2022
    Yeah no worries. You might want to join in the community at least because this kind of discussion is par for the course on the Slack. You might find a nice home here!

    > though its threading implementation may not be robust

    That's one of the main issues I have with it. Its poor threading behavior coupled with a bad default (https://github.com/JuliaLang/julia/issues/33409 one of my biggest pet peeve issues right now) really degrades real user performance.

    19 projects | news.ycombinator.com | 7 Jan 2022
    Yes, Julia does support arbitrary indexing because base functions are written in terms of `firstindex`, `eachindex` and `lastindex` etc.

    One can see it in the implementation of `filter!` for example https://github.com/JuliaLang/julia/blob/ab4e036b9209967b4273... :

  • NSW records 45,098 new cases and 9 deaths. 38.6% positivity rate. 145 people in ICU (8-Jan-2022)
    1 project | reddit.com/r/CoronavirusDownunder | 7 Jan 2022
    Julia is a programming language.
  • Julia Frameworks to Create Desktop GUI’s and Web Apps
    4 projects | news.ycombinator.com | 5 Jan 2022
    Thanks for the reply Jakob. I agree with what you are saying.

    When JET.jl works it is great. But for large projects it didn't even return when I tried it. I must have waited at least half an hour once.

    VSCode seems like it is offically blessed and maybe I should just cave and use it for Julia. I use vim/neovim for EVERYTHING else though. Taking me out of my extremely custom tmux + terminal + vim workflow just for Julia development annoys me unnecessarily much. Do you know if there's work on getting this to work in vim/neovim?

    ErrorTypes.jl, InlineTests.jl, ReTest.jl, SetField.jl all are awesome and I've used them in personal projects. I want to see them in the core language. Maybe ErrorTypes.jl is asking for too much, but tests sorely needs improvement. A SetField like feature literally had a PR open for years and then was just closed


    Without these features in the base language, adoption is going to be so slow. Convincing my team to add a dependency is a lot of work, including updating internal documents, best practices, internal training for how and when to use a certain feature, etc.

What are some alternatives?

When comparing db-benchmark and julia you can also consider the following projects:

Numba - NumPy aware dynamic Python compiler using LLVM

NetworkX - Network Analysis in Python

jax - Composable transformations of Python+NumPy programs: differentiate, vectorize, JIT to GPU/TPU, and more

rust-numpy - PyO3-based Rust binding of NumPy C-API

Lua - Lua is a powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description.

arrow-datafusion - Apache Arrow DataFusion and Ballista query engines

Dagger.jl - A framework for out-of-core and parallel execution

polars - Fast multi-threaded DataFrame library in Rust | Python | Node.js

duckdf - 🦆 SQL for R dataframes, with ducks

awesome-lisp-companies - Awesome Lisp Companies

py2many - Python to CLike languages transpiler

femtolisp - a lightweight, robust, scheme-like lisp implementation