Languages

Bash is GNU's Bourne-style shell and command language, used both interactively and as a scripting layer around Unix processes, files, pipelines, environment variables, and standard utilities.

Typing

dynamic

Runtime

interpreted by a shell process that expands commands, applies redirections, manages jobs, and launches builtins, functions, or external programs

Memory

managed by the shell process and external commands; scripts normally coordinate processes rather than allocate memory directly

C is a standardized systems programming language for native interfaces, operating-system and embedded work, language runtimes, and portable low-level libraries where explicit memory, layout, and ABI control matter.

Typing

static

Runtime

native code through hosted or freestanding implementations with no required garbage collector

Memory

manual memory management with automatic, static, allocated, and implementation-defined storage

C# is a statically typed, managed language centered on .NET, used for backend services, enterprise applications, Windows and cross-platform desktop apps, Unity games, cloud workloads, and tooling.

Typing

static

Runtime

.NET runtime and Common Language Runtime execution model

Memory

garbage collected managed heap with value types, spans, disposal patterns, and unsafe interop escape hatches

C++ is a standardized, multi-paradigm systems language for performance-critical native software, large C++ codebases, game engines, embedded application layers, libraries, and domains where zero-overhead abstractions and direct control must coexist.

Typing

static

Runtime

native code through implementation-defined compilers, standard libraries, ABIs, and optional runtime features

Memory

deterministic object lifetimes, RAII, smart pointers, value semantics, and manual escape hatches

Go is a statically typed, compiled language for services, network software, command-line tools, and infrastructure code that benefits from a small language surface, a strong standard toolchain, and built-in concurrency support.

Typing

static

Runtime

native binaries with Go runtime

Memory

garbage collected with explicit pointers and value semantics

Java is a statically typed, class-based language for the JVM, widely used for backend services, enterprise systems, Android-era application code, and long-lived software that benefits from managed runtime tooling and strong compatibility expectations.

Typing

static

Runtime

JVM bytecode on Java Virtual Machine implementations

Memory

garbage collected heap with managed object references

JavaScript is a dynamically typed, garbage-collected, prototype-based language standardized as ECMAScript and used across browsers, servers, edge runtimes, tools, and application scripting.

Typing

dynamic

Runtime

browser, server, edge, and embedded JavaScript runtimes

Memory

garbage collected by host engine

Kotlin is a statically typed JetBrains language for JVM, Android, JavaScript, Wasm, and native targets, best known for Java interoperability, null-safety features, coroutines, and Kotlin Multiplatform shared-code workflows.

Typing

static

Runtime

JVM bytecode, Android, JavaScript, Wasm, or native binaries through Kotlin target backends

Memory

managed by target runtime, including JVM garbage collection and Kotlin/Native tracing garbage collection

PHP is a dynamically typed, garbage-collected scripting language centered on server-side web applications, content management systems, request/response backends, and Composer-based package ecosystems.

Typing

dynamic

Runtime

Zend Engine interpreter for web server SAPIs, PHP-FPM, CLI scripts, workers, and embedded runtimes

Memory

automatic memory management through reference counting and cyclic garbage collection

Python is a dynamically typed, general-purpose language centered on readability, a large standard library, and a broad package ecosystem for scripting, automation, web services, data work, scientific computing, and machine learning.

Typing

dynamic

Runtime

interpreted bytecode on CPython and other Python implementations

Memory

garbage collected; CPython primarily uses reference counting plus cyclic garbage collection

R is a dynamically typed language and environment for statistical computing, graphics, data analysis, statistical modeling, and research workflows, with CRAN, data frames, packages, and reporting tools at the center of everyday use.

Typing

dynamic

Runtime

interpreted statistical computing environment with native extension interfaces

Memory

automatic garbage collection with R-managed objects and copy-on-modify user semantics

Ruby is a dynamically typed, garbage-collected language centered on expressive object-oriented programming, productive scripting, RubyGems and Bundler package workflows, and web application development shaped heavily by Ruby on Rails.

Typing

dynamic

Runtime

interpreted bytecode on CRuby/MRI and other Ruby implementations

Memory

automatic garbage collection

Rust is a statically typed systems language for software that needs low-level control, predictable performance, and strong compile-time memory and concurrency checks without a required garbage collector.

Typing

static

Runtime

native binaries with a small standard runtime; no required garbage collector

Memory

ownership, borrowing, lifetimes, and RAII without a required garbage collector

SQL is a standardized relational database language and dialect family for defining schemas, querying tables, changing data, expressing transactions, and moving work close to database engines.

Typing

static

Runtime

interpreted and optimized by relational database engines and dialect-specific execution layers

Memory

database-managed storage, buffers, indexes, transactions, and execution memory

Swift is a statically typed, compiled Apple-origin language for iOS, macOS, watchOS, tvOS, visionOS, server-side Linux services, command-line tools, packages, and emerging cross-platform targets, best known for optionals, value types, ARC, Swift concurrency, and Objective-C/C/C++ interoperability.

Typing

static

Runtime

native code through Swift toolchains, LLVM, platform SDKs, the Swift runtime, and target-specific standard/core libraries

Memory

automatic reference counting for class instances, value semantics for structs and enums, exclusivity checks, and explicit unsafe pointer escape hatches

TypeScript is a typed superset of JavaScript that adds static analysis and type annotations while compiling to JavaScript for existing runtimes.

Typing

static

Runtime

JavaScript runtime

Memory

host runtime managed