Programming-Language-Benchmarks
PackageCompiler.jl
Our great sponsors
Programming-Language-Benchmarks | PackageCompiler.jl | |
---|---|---|
19 | 26 | |
592 | 1,373 | |
- | 1.4% | |
5.3 | 7.8 | |
about 1 month ago | 16 days ago | |
C# | Julia | |
MIT License | MIT License |
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.
Programming-Language-Benchmarks
-
A Comprehensive Introduction to Golang
The benchmark available at https://programming-language-benchmarks.vercel.app/ demonstrates that Golang stands out as one of the most memory-efficient languages presently available. This achievement is attributable to several inherent features of Golang, such as its static typing, robust garbage collection system, and the inherent structuring of data within the language. These traits collectively contribute to Golang's exceptional efficiency in terms of minimal memory consumption compared to other languages.
- Rust vs Zig Benchmarks
-
Ask HN: What are some of the most elegant codebases in your favorite language?
I found Zig implementation of json parsing is interesting. The code is free from hidden control flow !.
https://github.com/hanabi1224/Programming-Language-Benchmark...
-
why does this while loop run instantly
I think https://programming-language-benchmarks.vercel.app/ is a good starting point to compare languages and compilers, also implementations are optimized for the specific language so you don't end up with a poorly ported c++ implementation in rust and wonder why it performs so bad.
- Why did tiger beetle choose zig over rust?
-
How fast is JIT compiled Lua/JavaScript compared to static compiled C++ and Rust measured in runtime?
It varies a lot depending on what the code consists of, but if you want concrete numbers for certain benchmarks, this site might be of interest: https://programming-language-benchmarks.vercel.app/
-
Speed Comparisons: JavaScript vs Python vs C vs Rust
There is not "one real" benchmark. In the end, all you can do is test languages for a specific feature / purpose. You can see how many different suggestions people have here, and here (I think) you can see the difficulties of comparing languages. That site uses quite a lot of algorithms / problems with multiple inputs, single and multithreaded, with different optimization flags (where applicable) and so on paired with different languages, and it's a mess. Sometimes one language is on top, sometimes another. (I mean, python will very rarely beat pure C, but I wont rule out that someone already created an edge case just to refute exactly this point)
- how to benchmark a programming language
- The original computer languages benchmark is back
-
Comparing Elixir with Rust and Go
Hello, World!: Elixir vs. Go vs. Rust
PackageCompiler.jl
-
Potential of the Julia programming language for high energy physics computing
Yes, julia can be called from other languages rather easily, Julia functions can be exposed and called with a C-like ABI [1], and then there's also various packages for languages like Python [2] or R [3] to call Julia code.
With PackageCompiler.jl [4] you can even make AOT compiled standalone binaries, though these are rather large. They've shrunk a fair amount in recent releases, but they're still a lot of low hanging fruit to make the compiled binaries smaller, and some manual work you can do like removing LLVM and filtering stdlibs when they're not needed.
Work is also happening on a more stable / mature system that acts like StaticCompiler.jl [5] except provided by the base language and people who are more experienced in the compiler (i.e. not a janky prototype)
[1] https://docs.julialang.org/en/v1/manual/embedding/
[2] https://pypi.org/project/juliacall/
[3] https://www.rdocumentation.org/packages/JuliaCall/
[4] https://github.com/JuliaLang/PackageCompiler.jl
[5] https://github.com/tshort/StaticCompiler.jl
- Strong arrows: a new approach to gradual typing
-
Making Python 100x faster with less than 100 lines of Rust
One of Julia's Achilles heels is standalone, ahead-of-time compilation. Technically this is already possible [1], [2], but there are quite a few limitations when doing this (e.g. "Hello world" is 150 MB [7]) and it's not an easy or natural process.
The immature AoT capabilities are a huge pain to deal with when writing large code packages or even when trying to make command line applications. Things have to be recompiled each time the Julia runtime is shut down. The current strategy in the community to get around this seems to be "keep the REPL alive as long as possible" [3][4][5][6], but this isn't a viable option for all use cases.
Until Julia has better AoT compilation support, it's going to be very difficult to develop large scale programs with it. Version 1.9 has better support for caching compiled code, but I really wish there were better options for AoT compiling small, static, standalone executables and libraries.
[1]: https://julialang.github.io/PackageCompiler.jl/dev/
-
What's Julia's biggest weakness?
Doesn’t work on Windows, but https://github.com/JuliaLang/PackageCompiler.jl does.
-
I learned 7 programming languages so you don't have to
Also, you can precompile a whole package and just ship the binary. We do this all of the time.
https://github.com/JuliaLang/PackageCompiler.jl
And getting things precompiled: https://sciml.ai/news/2022/09/21/compile_time/
-
Julia performance, startup.jl, and sysimages
You can have a look at PackageCompiler.jl
-
Why Julia 2.0 isn’t coming anytime soon (and why that is a good thing)
I think by PackageManager here you mean package compiler, and yes these improvements do not need a 2.0. v1.8 included a few things to in the near future allow for building binaries without big dependencies like LLVM, and finishing this work is indeed slated for the v1.x releases. Saying "we are not doing a 2.0" is precisely saying that this is more important than things which change the user-facing language semantics.
And TTFP does need to be addressed. It's a current shortcoming of the compiler that native and LLVM code is not cached during the precompilation stages. If such code is able to precompile into binaries, then startup time would be dramatically decreased because then a lot of package code would no longer have to JIT compile. Tim Holy and Valentin Churavy gave a nice talk at JuliaCon 2022 about the current progress of making this work: https://www.youtube.com/watch?v=GnsONc9DYg0 .
This is all tied up with startup time and are all in some sense the same issue. Currently, the only way to get LLVM code cached, and thus startup time essentially eliminated, is to build it into what's called the "system image". That system image is the binary that package compiler builds (https://github.com/JuliaLang/PackageCompiler.jl). Julia then ships with a default system image that includes the standard library in order to remove the major chunk of code that "most" libraries share, which is why all of Julia Base works without JIT lag. However, that means everyone wants to have their thing, be it sparse matrices to statistics, in the standard library so that it gets the JIT-lag free build by default. This means the system image is huge, which is why PackageCompiler, which is simply a system for building binaries by appending package code to the system image, builds big binaries. What needs to happen is for packages to be able to precompile in a way that then caches LLVM and native code. Then there's no major compile time advantage to being in the system image, which will allow things to be pulled out of the system image to have a leaner Julia Base build without major drawbacks, which would then help make the system compile. That will then make it so that an LLVM and BLAS build does not have to be in every binary (which is what takes up most of the space and RAM), which would then allow Julia to much more comfortably move beyond the niche of scientific computing.
- Is it possible to create a Python package with Julia and publish it on PyPi?
- GenieFramework – Web Development with Julia
-
Julia for health physics/radiation detection
You're probably dancing around the edges of what [PackageCompiler.jl](https://github.com/JuliaLang/PackageCompiler.jl) is capable of targeting. There are a few new capabilities coming online, namely [separating codegen from runtime](https://github.com/JuliaLang/julia/pull/41936) and [compiling small static binaries](https://github.com/tshort/StaticCompiler.jl), but you're likely to hit some snags on the bleeding edge.
What are some alternatives?
Programming-Language-Benchmark
StaticCompiler.jl - Compiles Julia code to a standalone library (experimental)
svix-webhooks - The enterprise-ready webhooks service 🦀
julia - The Julia Programming Language
rust-csharp-ffi - An example Rust + C# hybrid application
Genie.jl - 🧞The highly productive Julia web framework
Game-Of-Life-Implementations - Conway's Game of Life implementation in various languages
LuaJIT - Mirror of the LuaJIT git repository
sb-simd - A convenient SIMD interface for SBCL.
Dash.jl - Dash for Julia - A Julia interface to the Dash ecosystem for creating analytic web applications in Julia. No JavaScript required.
lish - Lisp Shell
Transformers.jl - Julia Implementation of Transformer models