Software

/ˌaɪ ˈɑːr/

noun … “The shared language between source code and machines.”

IR, short for Intermediate Representation, is an abstract, structured form of code used internally by a Compiler to bridge the gap between high-level source languages and low-level machine instructions. It is not meant to be written by humans or executed directly by hardware. Instead, IR exists as a stable, analyzable format that enables transformation, optimization, and portability across languages and architectures.

/ˌɛl ɛl viː ɛm/

noun … “Reusable compiler infrastructure built for optimization.”

LLVM, short for Low Level Virtual Machine, is a modular compiler infrastructure designed to support the construction of programming language toolchains, advanced optimizers, and code generators. Rather than being a single compiler, LLVM is a collection of reusable components that can be assembled to build Compilers, static analysis tools, just-in-time systems, and ahead-of-time pipelines targeting many hardware architectures.

/ˈpɒliˌɡlɒt ˈproʊɡræmɪŋ/

noun … “Writing software that spans multiple programming languages.”

/ɡreɪl/

noun … “Optimizing compiler for the JVM ecosystem.”

Graal is a high-performance just-in-time (JIT) compiler and runtime component that targets the Java Virtual Machine. It replaces or supplements the traditional HotSpot JIT compiler to provide advanced optimizations, improved code generation, and support for dynamic languages on the JVM. By performing aggressive inlining, partial evaluation, and runtime profiling, Graal enhances execution speed and reduces memory overhead for both Java and polyglot workloads.

/ɡreɪl viː ɛm/

noun … “Polyglot JVM for high-performance execution.”

/ˈmoʊnædz/

noun … “Composable containers for managing computation and effects.”

/taɪp ˈsɪstəm/

noun … “Rules governing the kinds of data and operations in a language.”

Type System is a formal framework in programming languages that classifies values, expressions, and variables into types, specifying how they can interact and which operations are valid. A robust type system enforces correctness, prevents invalid operations, and allows the compiler or runtime to catch errors early. Type systems can be static or dynamic, strong or weak, and often support features such as generics, type inference, and polymorphism.

/ˈækə/

noun … “Toolkit for building concurrent, distributed, and resilient systems.”

/ˌhaɪər ˈɔːrdər ˈfʌŋkʃən/

noun … “A function that operates on other functions.”

Higher-Order Function is a function that either takes one or more functions as arguments, returns a function as its result, or both. This concept is fundamental in Functional Programming, allowing programs to abstract behavior, compose operations, and manipulate computations as first-class values. By treating functions as data, developers can build flexible, reusable, and declarative pipelines.

/ˌɪˌmjuːtəˈbɪləti/

noun … “Data that never changes after creation.”

Immutability is the property of data structures or objects whose state cannot be modified once they are created. In programming, using immutable structures ensures that any operation producing a change returns a new instance rather than altering the original. This paradigm is central to Functional Programming, concurrent systems, and applications where predictable state is critical.