LLVM vs JVM
Compile time:
- JVM: compiles source code (e.g. Java / Kotlin / Scala) to bytecode;
- LLVM:
- front-end (e.g. Clang / Flang) compiles source code to IR (intermediate representation, IR was designed from the beginning to be a portable assembly.)
- back-end turns IR into a native binary executable.
Runtime:
- JVM: garbage collection, access to resources, etc. JVM is an interpreter for Java bytecode, It has to be running during program execution. (Bigger size and higher overhead).
- LLVM: not needed during runtime (since it generates architecture specific executables in advance)
Just-in-time and Ahead-of-time
As discussed above, LLVM is primarily ahead-of-time, JVM is primarily just-in-time.
LLVM also supports just-in-time compiling (based on the generated IR), since in some cases code needs to be generated on the fly, e.g. when using REPL in Julia. (lli: directly executes programs in LLVM bitcode format. It takes a program in LLVM bitcode format and executes it using a just-in-time compiler or an interpreter.)
GraalVM can compile JAVA application ahead-of-time to native binaries.
register-based vs stack-based
- LLVM: low level, register-based virtual machine. It is designed to abstract the underlying hardware and draw a clean line between a compiler back-end (machine code generation) and front-end (parsing, etc.).
- JVM: higher level, stack-based virtual machine (rather than loading values into registers, JVM bytecode loads values onto a stack and computes values from there).
Cross Language
Because of IR and bytecode, both LLVM and JVM can support multiple languages.
- LLVM: C, C++, Rust, Swift, Fortran, Kotlin/Native, etc.
- JVM: Java, Kotlin/JVM, Scala, Groovy, Closure, etc.
- GraalVM: Java, JavaScript, Python, Ruby, R, WASM, etc.
LLVM provide primitives for common programming languages features. E.g. functions, global variables, coroutines and C foreign-function interfaces. LLVM has many of these as standard elements in its IR. The split of front-end and backend-end frees high-level language compilers from having to target every platform (they only need to emit LLVM intermediate representation).
LLVM front-ends:
- Clang: for C family of languages, e.g. C, C++, Objective-C
- Flang: for Fortran, added in LLVM 13
Implementation
- LLVM itself is written in C++; it provides C and C++ APIs.
- OpenSDK is written in C++.
- GraalVM is written in Java.
- 32-bit vs 64-bit
- AES vs RSA
- Agent vs Agentless
- Annotations vs Decorators
- Terraform vs Ansible
- BASH vs ZSH
- BigQuery vs Bigtable
- Block Storage vs File Storage vs Object Storage
- Canvas vs SVG
- cgroupfs vs systemd
- Constructor vs Init() vs Factory
- Container Image vs Helm Chart vs OCI Bundle
- Containers vs Virtual Machines (VMs)
- C vs C++
- Java vs C++
- Rust vs C++
- crictl vs ctr
- Dagger vs Guice
- DMA vs RDMA
- DOM vs Virtual DOM vs Shadow DOM
- DQL vs DDL vs DCL vs DML
- eBPF vs Sidecar
- Flux vs Redux
- Full Disk Encryption vs Partition Encryption
- Gatekeeper vs OPA
- Google vs Open Source
- Why MCP uses JSON-RPC 2.0 instead of grpc
- gRPC vs OpenAPI
- gtag.js vs Google Tag Manager (GTM)
- Versus
- Kotlin vs Java
- Jetty vs Netty
- .js vs .jsx vs .ts vs .tsx
- Kata Containers vs KubeVirt
- Linux Namespace vs Kubernetes Namespace
- Linux vs BSD
- LLVM vs JVM
- Data Mining vs Machine Learning vs Artificial Intelligence vs Data Science
- Managed Kubernetes vs Self-managed Kubernetes
- Management Plane vs Control Plane vs Data Plane
- Microcontroller vs Microprocessor vs Computer
- MMU vs IOMMU
- Single-tenant vs Multi-tenant vs Multi-single-tenant
- Multithreading vs Multiprocessing vs Distributed Systems
- Node.js vs Erlang
- OCI Image vs Docker Image
- OCI vs CRI
- OpenSSH vs OpenSSL
- Pass-by-value vs Pass-by-reference
- Podman vs nerdctl
- POSIX vs SUS vs LSB
- Private Key vs Public Key vs Certificate
- Proto Edition 2024 vs Proto Edition 2023
- Proto2 vs Proto3 vs Proto Editions
- Message Queue vs PubSub
- React vs Flutter vs Angular
- REST vs SOAP
- RSA vs ECDSA
- select vs. poll vs. epoll
- SLI vs SLO vs SLA
- Spanner vs Bigtable
- Static Site Generation vs Server-side Rendering vs Client-side Rendering
- Stack based VM vs Register based VM
- Stateless vs Stateful
- Strong Consistency vs Eventual Consistency
- stubs vs mocks vs fakes
- Subroutines vs Coroutines vs Generators
- Software Engineer vs Site Reliability Engineer
- Symlinks vs Hard Links
- JAX vs Tensorflow
- Tensorflow vs PyTorch
- Terminal vs Shell
- Throttling vs Load Shedding
- Unix Domain Sockets vs Network Sockets
- Unix Domain Sockets vs Shared Memory
- URI vs URN vs URL vs URC
- Valkey vs Redis vs Memcached
- Vi vs Vim vs gVim vs Neovim
- WAL vs rollback journal

