Programming Languages on devtools/

Mon, 01 Jan 0001 00:00:00 +0000

ABAP (Advanced Business Application Programming) runs inside the SAP NetWeaver application server and powers the business logic of SAP ERP, S/4HANA, and related enterprise systems. With an installed base spanning most large enterprises worldwide, there are millions of lines of ABAP in production. Modern ABAP supports object-oriented programming, RESTful APIs, and cloud deployment.

Mon, 01 Jan 0001 00:00:00 +0000

ActionScript 3 powered the Flash ecosystem that dominated interactive web content, online games, and video delivery before HTML5. Its class system and event model influenced early JavaScript frameworks. Adobe AIR allowed ActionScript to build cross-platform desktop applications. Flash’s end-of-life in 2020 has made ActionScript legacy, but large codebases and game libraries survive in emulation.

Mon, 01 Jan 0001 00:00:00 +0000

Ada was designed to be readable, verifiable, and correct — features that matter when software controls aircraft, missiles, or train signalling systems. Its strong typing, range constraints, and tasking model prevent entire categories of bugs at compile time. SPARK, a formally verifiable subset of Ada, is used to prove software correctness in safety-critical domains.

Mon, 01 Jan 0001 00:00:00 +0000

Agda is both a proof assistant and a programming language — proofs are programs and programs are proofs. It is used in academic research to formalise mathematics (the HoTT book was typeset using Agda proofs) and to verify correctness of algorithms and protocols. Its interactive editor mode in Emacs allows filling in proof holes incrementally.

Mon, 01 Jan 0001 00:00:00 +0000

Apex runs in a multi-tenant cloud environment inside Salesforce and enforces strict governor limits on CPU time, heap, and DML operations to protect shared infrastructure. It is used to write triggers, batch jobs, web services, and complex business workflows on the Salesforce platform. Knowledge of Apex is essential for Salesforce developers and administrators.

Mon, 01 Jan 0001 00:00:00 +0000

APL’s symbol-based notation allows entire algorithms to be expressed in a single line by composing operations over arrays. Developed by Kenneth Iverson, it pioneered array-oriented programming and influenced languages from MATLAB to Julia. Its direct descendants J and K are used extensively in high-frequency trading for their terseness and performance.

Mon, 01 Jan 0001 00:00:00 +0000

Assembly language maps one-to-one to CPU instructions, giving complete control over registers, memory, and hardware. While rarely used for full applications today, it remains essential for boot loaders, hardware drivers, crypto primitives, and performance-critical hot paths. Popular assemblers include NASM (x86), GAS (GNU), and LLVM’s integrated assembler.

Mon, 01 Jan 0001 00:00:00 +0000

AWK processes text files line by line, matching each line against patterns and executing corresponding actions. A one-liner can sum a column, filter rows, reformat CSV, or extract fields from log files. gawk (GNU AWK) extends the original with network I/O, arrays, and Unicode. AWK is available on every Unix-like system and remains invaluable for data wrangling in pipelines.

Mon, 01 Jan 0001 00:00:00 +0000

Ballerina treats network communication as a first-class concern — services, clients, and data formats (JSON, XML, CSV) are built into the type system. Its graphical sequence diagram view is automatically generated from code, making service interactions visible. It targets integration and API development as a higher-level alternative to Java or Go microservices.

Mon, 01 Jan 0001 00:00:00 +0000

Bash is the lingua franca of Unix automation — cron jobs, deployment scripts, CI pipelines, and dotfiles are almost universally written in it. Despite quirky syntax, its ubiquity on every Linux server and macOS machine makes it an essential tool for every developer.

Mon, 01 Jan 0001 00:00:00 +0000

C was designed to write Unix and has since become the lingua franca of systems programming. Nearly every operating system kernel, embedded microcontroller, and runtime (including Python and Ruby) has C at its core. Its manual memory model and minimal runtime overhead make it irreplaceable for performance-critical software.

Mon, 01 Jan 0001 00:00:00 +0000

Carbon is designed as a successor to C++ rather than a rewrite-from-scratch language, offering bidirectional C++ interop so teams can migrate incrementally. It addresses C++’s legacy technical debt — complex syntax, undefined behaviour, and slow compile times — while targeting the same performance-critical use cases. As of 2024 it is still pre-1.0 and under active development.

Mon, 01 Jan 0001 00:00:00 +0000

Chapel was designed at Cray to make parallel computing productive without sacrificing performance. Its unified memory model, domain maps, and forall loops enable the same code to scale from a laptop to a supercomputer. Chapel has been used to build large-scale data analytics tools and genomics pipelines that run on thousands of nodes.

Mon, 01 Jan 0001 00:00:00 +0000

Clean is a lazily-evaluated, purely functional language similar to Haskell, but with uniqueness types instead of monads for handling state and I/O. Uniqueness types allow safe in-place mutation of values when it can be proved only one reference exists. Clean compiles to highly efficient native code and influenced the linear and affine type systems in Rust and other languages.

Mon, 01 Jan 0001 00:00:00 +0000

Clojure brings Lisp’s power to the JVM with persistent immutable data structures, software transactional memory, and a culture of interactive REPL-driven development. ClojureScript compiles to JavaScript for frontend use. Its emphasis on simplicity and data-oriented programming has made it influential in the functional programming community and successful at companies like Nubank.

Mon, 01 Jan 0001 00:00:00 +0000

COBOL was designed to be readable by non-programmers and to process business records at scale. Roughly 95% of ATM transactions and the majority of banking core systems worldwide still run on COBOL. Billions of lines of COBOL code run on IBM mainframes, and skilled COBOL developers remain in high demand.

Mon, 01 Jan 0001 00:00:00 +0000

CoffeeScript pioneered many features — arrow functions, destructuring, classes, string interpolation — years before they appeared in ES6. While largely superseded by modern JavaScript and TypeScript, it influenced the entire JavaScript ecosystem’s evolution and introduced a generation of developers to cleaner syntax.

Mon, 01 Jan 0001 00:00:00 +0000

Common Lisp was standardised by ANSI in 1994 and remains one of the most powerful general-purpose languages. Its macro system operates on the abstract syntax tree, enabling language-level abstractions impossible in other languages. SBCL produces highly optimised native code. Common Lisp was the dominant AI language of the 1980s and is still used in production at companies like Grammarly.

Mon, 01 Jan 0001 00:00:00 +0000

Coq is one of the most widely used proof assistants in computer science. The CompCert formally verified C compiler was proved correct in Coq, as was the seL4 microkernel. Coq proofs are checked by a small trusted kernel, making it applicable to safety-critical certification. Coq is now renamed Rocq following a 2024 community decision.

Mon, 01 Jan 0001 00:00:00 +0000

C++ adds zero-cost abstractions, templates, and RAII to C while retaining full control over memory and hardware. It powers game engines (Unreal, Unity’s runtime), browsers (Chrome, Firefox), databases (MySQL, MongoDB), and any software where raw throughput matters. Modern C++20/23 continues to evolve the language toward safer, more expressive code.

Mon, 01 Jan 0001 00:00:00 +0000

Crystal gives Ruby developers a familiar syntax with static type checking and LLVM-backed native compilation. Type inference keeps code clean while eliminating entire categories of runtime errors. Its built-in concurrency primitives (fibers and channels) and zero-overhead C bindings make it suitable for high-performance web services and systems tooling.

Mon, 01 Jan 0001 00:00:00 +0000

C# combines Java-style object orientation with modern language features like pattern matching, records, nullable reference types, and async/await. On .NET 8+ it compiles to native via AOT for performance-sensitive workloads. Unity’s adoption of C# for game scripting makes it one of the most widely used game development languages.

Mon, 01 Jan 0001 00:00:00 +0000

D was designed by Walter Bright to address C++’s complexity while retaining its performance characteristics. It supports both garbage-collected and manual memory management, has a sophisticated template metaprogramming system, and includes built-in unit testing and contract programming. The Dub package manager and DMD compiler make the development experience approachable.

Mon, 01 Jan 0001 00:00:00 +0000

Dart compiles to native ARM code for mobile and desktop, and to JavaScript for the web. Flutter’s adoption of Dart as its primary language has driven significant growth in the Dart ecosystem. Sound null safety, hot reload, and a fast ahead-of-time compiler make it well-suited for UI-heavy applications.

Mon, 01 Jan 0001 00:00:00 +0000

Delphi combines Object Pascal with a visual component library for rapid native application development. It compiles to native binaries for Windows, macOS, iOS, Android, and Linux from a single codebase. Despite low visibility in open-source communities, it has a large installed base in healthcare, finance, and logistics applications, many of which have run continuously for decades.

Mon, 01 Jan 0001 00:00:00 +0000

Eiffel introduced Design by Contract as a first-class language feature — methods declare preconditions they expect, postconditions they guarantee, and class invariants that must always hold. Violations are caught at runtime with precise diagnostics. Its concepts directly influenced the assert and ensure patterns in many languages and formal methods research.

Mon, 01 Jan 0001 00:00:00 +0000

Elixir runs on the BEAM virtual machine, inheriting Erlang’s proven model for building systems that handle millions of concurrent connections with sub-millisecond latency. The Phoenix framework and LiveView have made Elixir popular for real-time web applications. Its actor model, lightweight processes, and supervision trees make it uniquely suited for building reliable distributed systems.

Mon, 01 Jan 0001 00:00:00 +0000

Elm’s strict functional model means every value is immutable and every function is pure — the compiler catches all type errors before runtime, famously producing no runtime exceptions in production applications. Its Elm Architecture (Model-Update-View) pattern influenced Redux and many modern state management solutions.

Mon, 01 Jan 0001 00:00:00 +0000

Erlang was built by Ericsson to power telephone switches that could not go down. Its actor model, supervision trees, and hot code reloading enable systems with “nine nines” (99.9999999%) uptime. WhatsApp ran on Erlang and scaled to 2 million concurrent connections per server. Elixir inherits the BEAM VM and all its reliability guarantees.

Mon, 01 Jan 0001 00:00:00 +0000

Factor is a modern concatenative language where all computation operates on a data stack and programs are built by composing named words. It features an image-based development environment, a JIT compiler, and a comprehensive standard library covering web, crypto, and parsing. Its quotation-based higher-order functions make functional patterns natural and concise.

Mon, 01 Jan 0001 00:00:00 +0000

Fennel compiles to Lua with no runtime overhead — the output is idiomatic Lua code. It adds destructuring, pattern matching, and a hygienic macro system to Lua’s platform. It is popular in the Neovim plugin ecosystem, game development with LÖVE, and anywhere Lua is already embedded. Fennel configuration is used by many Neovim users as an alternative to Lua.

Mon, 01 Jan 0001 00:00:00 +0000

Forth is built around a data stack and a return stack — all operations push and pop values. Its self-hosting compiler can be implemented in under 1000 words of machine code, making it popular for bootstrapping systems with minimal resources. OpenFirmware (used in Sun, Apple PowerPC, and OLPC machines) is implemented in Forth, as are many embedded microcontroller environments.

Mon, 01 Jan 0001 00:00:00 +0000

Fortran (Formula Translation) was the first language to demonstrate that high-level code could match hand-written assembly in performance. It remains in active use for climate models, computational fluid dynamics, quantum chemistry codes, and any domain where numerical performance is paramount. Modern Fortran (2018+) supports coarrays, object-orientation, and interoperability with C.

Mon, 01 Jan 0001 00:00:00 +0000

F# brings OCaml-style functional programming to the .NET ecosystem. Its algebraic data types, pattern matching, and type inference result in concise, correct code with minimal boilerplate. It is widely used in financial services (Jet.com, Kaggle), scientific computing, and anywhere data transformation pipelines benefit from immutable types.

Mon, 01 Jan 0001 00:00:00 +0000

Gleam brings static typing to the BEAM VM — the runtime behind Erlang and Elixir — without sacrificing interoperability with the existing ecosystem. Its friendly error messages, algebraic data types, and pattern matching make concurrent, fault-tolerant systems accessible to developers coming from typed languages like Rust or TypeScript.

Mon, 01 Jan 0001 00:00:00 +0000

Go was designed at Google to be fast to compile, easy to read, and excellent at handling concurrency. It powers Docker, Kubernetes, and many cloud-native tools.

Mon, 01 Jan 0001 00:00:00 +0000

Grain compiles to WebAssembly as a first-class target, making it suitable for browser plugins, serverless functions, and edge computing. Its type system with automatic memory management and immutable-by-default values makes it safe for untrusted execution environments. Grain’s syntax draws from ML and Rust, targeting developers who want functional safety in Wasm contexts.

Mon, 01 Jan 0001 00:00:00 +0000

Groovy’s seamless Java interoperability and concise syntax made it the language of choice for Gradle build scripts and Jenkins pipeline definitions. Its closure support and dynamic capabilities enable expressive DSLs. The Grails web framework brought Groovy to full-stack web development.

Mon, 01 Jan 0001 00:00:00 +0000

Hack was developed at Facebook to bring static typing to a PHP codebase with hundreds of millions of lines. It runs on HHVM and adds generics, nullable types, lambdas, and async/await to PHP’s model. The gradual type system allows incremental migration of existing PHP code.

Mon, 01 Jan 0001 00:00:00 +0000

Haskell enforces pure functional programming — functions have no side effects unless explicitly typed that way — enabling the compiler to make strong guarantees about code correctness. Its type system, including type classes and higher-kinded types, has influenced languages from Rust to Scala. It is widely used in compilers, formal verification, and quantitative finance.

Mon, 01 Jan 0001 00:00:00 +0000

HCL is designed to be readable by humans and parseable by machines, striking a balance between JSON’s machine-friendliness and YAML’s human-friendliness. It is the language of Terraform and Packer, where it describes cloud resources, providers, and modules. Its expression language, functions, and for-loops make it capable of non-trivial infrastructure logic.

Mon, 01 Jan 0001 00:00:00 +0000

Idris extends the Curry-Howard correspondence to its logical conclusion — a dependent type system where the distinction between programs and proofs dissolves. You can write a type that says “this function returns a sorted list” and the compiler will enforce it. Idris 2 is built on Quantitative Type Theory and compiles to native code via Chez Scheme.

Mon, 01 Jan 0001 00:00:00 +0000

Io was designed as a thought experiment in minimalism — the entire language is built from objects that pass messages to each other. There are no classes, only prototypes. Coroutines and actors are built in. Steve Dekorte created Io as an exploration of the smallest syntax that could support a complete programming model, influencing several later languages.

Mon, 01 Jan 0001 00:00:00 +0000

J is Kenneth Iverson’s redesign of APL using ASCII characters instead of special symbols. Like APL, it operates natively on arrays — a single expression can process an entire dataset. Tacit (point-free) programming style allows composing verbs without naming arguments. J is used in quantitative finance and mathematical research where dense, exact notation matters.

Mon, 01 Jan 0001 00:00:00 +0000

Janet is a Lisp that compiles to bytecode and is easy to embed in C applications. Its persistent data structures, coroutines, and macro system make it expressive for scripting and configuration. The entire runtime fits in a few hundred KB, making it suitable for resource-constrained environments. It is used as the build system DSL for jpm (Janet’s package manager).

Mon, 01 Jan 0001 00:00:00 +0000

Java’s JVM compiles once and runs anywhere, making it the backbone of enterprise software, Android apps, and distributed systems like Hadoop and Kafka. Its strong typing, mature ecosystem, and vast library of frameworks (Spring, Jakarta EE) keep it one of the most deployed languages in the world.

Mon, 01 Jan 0001 00:00:00 +0000

JavaScript is the only language that runs natively in web browsers, making it the universal language of the web. With Node.js it also powers backends, CLIs, and desktop apps.

Mon, 01 Jan 0001 00:00:00 +0000

Julia uses LLVM-based JIT compilation to achieve performance competitive with C for numerical workloads, while retaining Python-like syntax and interactivity. Multiple dispatch is a first-class language feature rather than an afterthought. It is widely adopted in computational biology, climate modelling, quantum computing research, and high-performance numerical simulation.

Mon, 01 Jan 0001 00:00:00 +0000

Koka’s type system tracks all side effects — exceptions, state, I/O, concurrency — as first-class row-typed effect labels. Algebraic effect handlers provide a structured way to implement custom control flow, coroutines, and exception systems. Koka pioneered Reuse Analysis, a compile-time technique for in-place mutation of functional data structures that Lean 4 and other languages have adopted.

Mon, 01 Jan 0001 00:00:00 +0000

Kotlin is fully interoperable with Java but eliminates much of its boilerplate — data classes, extension functions, null safety, and coroutines are all first-class. Google made it the preferred language for Android in 2019. Kotlin Multiplatform now allows sharing business logic across Android, iOS, and the web from a single codebase.

Mon, 01 Jan 0001 00:00:00 +0000

Lean 4 is both a proof assistant and a full-featured functional programming language with dependent types. The Mathlib library contains tens of thousands of formalised mathematical results. Projects like the Liquid Tensor Experiment demonstrated that professional mathematicians can use Lean to formalise cutting-edge research, driving significant growth in its community.

Mon, 01 Jan 0001 00:00:00 +0000

Lobster combines a Python-like syntax with a sophisticated static type system that infers types flow-sensitively and tracks object lifetimes without a garbage collector. It compiles to C++ or WASM for deployment and is designed as a safe scripting layer for games. Its coroutine support and vector operations make it expressive for game AI and procedural generation.

Mon, 01 Jan 0001 00:00:00 +0000

Lua was designed to be small, fast, and easy to embed in larger applications. It powers game scripting in engines like Corona, Defold, and Roblox, configuration in tools like Neovim and Redis, and plugin systems in dozens of applications. LuaJIT’s tracing compiler makes it one of the fastest dynamic languages available.

Mon, 01 Jan 0001 00:00:00 +0000

MATLAB combines a matrix-centric language with a rich toolbox ecosystem covering signal processing, control systems, machine learning, and image processing. It is deeply embedded in academia and engineering workflows at aerospace, automotive, and electronics companies worldwide. GNU Octave provides a largely compatible open-source alternative.

Mon, 01 Jan 0001 00:00:00 +0000

Mercury combines Prolog’s logic programming model with a strict static type system, determinism annotations, and compilation to efficient native code. The mode system tracks whether variables are inputs or outputs, eliminating the non-determinism pitfalls of Prolog. It is used in research and in the Aditi deductive database system.

Mon, 01 Jan 0001 00:00:00 +0000

Modula-2 was designed by Niklaus Wirth as a systems programming language addressing Pascal’s limitations. Its module system — separate interface and implementation units with explicit imports — directly influenced the module systems of Ada, Oberon, and indirectly Java packages and C++ namespaces. It was used to write operating systems and embedded software in the 1980s.

Mon, 01 Jan 0001 00:00:00 +0000

Mojo is designed to be a superset of Python that can compile to hardware-specific code via MLIR, achieving performance competitive with C++ and CUDA while retaining Python syntax. It targets AI and machine learning engineers who want GPU-level performance without leaving the Python ecosystem. Developed by the team behind LLVM and Swift.

Mon, 01 Jan 0001 00:00:00 +0000

Nim compiles to C, C++, or JavaScript and produces binaries competitive with hand-written C. Its macro system enables compile-time code generation without preprocessor hacks. Nim occupies a sweet spot between the expressiveness of Python and the performance of C, making it appealing for systems tooling, game development, and embedded scripting.

Mon, 01 Jan 0001 00:00:00 +0000

The Nix language is a lazily-evaluated, purely functional expression language used to describe packages, their dependencies, and system configurations. Everything in Nix is an expression that evaluates to a derivation — a precise, reproducible build specification. NixOS uses it to describe an entire Linux system, enabling atomic upgrades and rollbacks.

Mon, 01 Jan 0001 00:00:00 +0000

Objective-C was the dominant language for Apple platform development for over 30 years. Its dynamic message-passing runtime powers Cocoa and UIKit, and a vast body of iOS and macOS libraries are still written in it. Apple introduced Swift in 2014 as its successor, but Objective-C codebases remain widespread and the two languages interoperate seamlessly.

Mon, 01 Jan 0001 00:00:00 +0000

OCaml’s Hindley-Milner type system catches entire classes of bugs at compile time while its module system enables large-scale software architecture. It was the language of choice at Jane Street (financial trading) and inspired Rust’s ownership model. The Reason/ReScript dialects bring OCaml’s type system to JavaScript development.

Mon, 01 Jan 0001 00:00:00 +0000

Odin was designed with game development and systems programming in mind — explicit allocators, context-based memory management, and a clear, readable syntax without C’s historical baggage. It compiles via LLVM and supports multiple calling conventions for C interop. The Odin compiler itself, a game engine, and several tools are written in Odin.

Mon, 01 Jan 0001 00:00:00 +0000

Pascal was designed by Niklaus Wirth as a clean, teachable language that enforced structured programming. It was the dominant language in computer science education through the 1980s and early 1990s. Free Pascal and Lazarus keep it alive as a cross-platform compiled language; Delphi (Object Pascal) is Pascal’s commercial descendant still in active use.

Mon, 01 Jan 0001 00:00:00 +0000

Perl’s “there’s more than one way to do it” philosophy and unmatched regular expression integration made it the dominant glue language of the early web. It remains heavily used in bioinformatics (BioPerl), legacy systems administration, and anywhere dense text transformation is required. CPAN, Perl’s package repository, contains over 200,000 modules.

Mon, 01 Jan 0001 00:00:00 +0000

PHP runs on the majority of web servers and is the foundation of WordPress, Drupal, and many CMSes. Modern PHP (8.x) has a mature type system, JIT compilation, and a thriving ecosystem via Composer.

Mon, 01 Jan 0001 00:00:00 +0000

Pony’s reference capability system encodes aliasing and mutability at the type level, making data races and deadlocks impossible by construction — not just unlikely, but unrepresentable. Its actor model uses work-stealing for efficient concurrency without locks. Pony compiles to native code via LLVM and is used in research into safe high-performance concurrent systems.

Mon, 01 Jan 0001 00:00:00 +0000

PowerShell treats everything as a .NET object — pipelines pass structured objects rather than plain text, making complex system administration tasks concise and composable. PowerShell Core 6+ is fully cross-platform. It is the primary automation language for Azure, Active Directory, and Windows infrastructure management.

Mon, 01 Jan 0001 00:00:00 +0000

Prolog executes by unifying terms and performing depth-first search with backtracking — the runtime figures out how to satisfy a query from a set of declared facts and rules. It was central to the Japanese Fifth Generation Computer project and is still used in natural language processing, theorem proving, and expert systems.

Mon, 01 Jan 0001 00:00:00 +0000

PureScript brings Haskell’s type system to JavaScript compilation — row polymorphism, type classes, higher-kinded types, and strict evaluation. Unlike Elm it makes no simplifying concessions, giving developers the full power of a Haskell-like type system for frontend code. It is used in production at SlamData, Awake Security, and other companies valuing correctness.

Mon, 01 Jan 0001 00:00:00 +0000

Python’s readable syntax and vast standard library make it the go-to language for data science, machine learning, scripting, and web backends. It consistently ranks as the world’s most popular language.

Mon, 01 Jan 0001 00:00:00 +0000

R was built by statisticians for statistics and remains the dominant language in academia, biostatistics, and quantitative research. The tidyverse ecosystem (ggplot2, dplyr, tidyr) provides a coherent, expressive grammar for data manipulation and visualisation. R Shiny enables interactive web-based dashboards from pure R code.

Mon, 01 Jan 0001 00:00:00 +0000

Racket’s defining feature is its language tower — you can define new languages with custom syntax and semantics within the same ecosystem, using #lang directives. It is the platform behind How to Design Programs, one of the most influential programming curricula. Typed Racket adds a gradual type system, and it is widely used in programming language research.

Mon, 01 Jan 0001 00:00:00 +0000

Rebol’s central concept is that code is data and data is code — its flexible value types and lack of reserved words allow defining domain-specific dialects within the same parser. Red, an open-source successor, adds native compilation and a GUI toolkit. Carl Sassenrath designed Rebol after working on the Amiga OS; its ideas influenced several modern DSL-oriented languages.

Mon, 01 Jan 0001 00:00:00 +0000

ReScript combines OCaml’s sound type system with a JavaScript-friendly syntax, producing readable and performant JavaScript output. Its type inference is fast and complete — zero any, zero runtime type errors. It has first-class React bindings and is used by teams at Meta and in the broader OCaml/Reason community.

Mon, 01 Jan 0001 00:00:00 +0000

REXX (Restructured Extended Executor) was designed with readability as its primary goal — it reads like pseudocode. It remains the native scripting language for IBM z/OS mainframes and is used for automating JCL, TSO/ISPF interfaces, and batch processing. NetRexx compiles REXX to the JVM; Open Object REXX adds OOP capabilities.

Mon, 01 Jan 0001 00:00:00 +0000

Roc is designed to be fast, friendly, and correct — no null values, no runtime exceptions, and a type system that catches errors before they reach production. It uses algebraic effects for managing side effects and compiles via LLVM to native code. Roc’s platform model cleanly separates pure logic from effect-ful platform code, making business logic fully portable.

Mon, 01 Jan 0001 00:00:00 +0000

Ruby’s clean syntax and powerful metaprogramming capabilities made it the language that popularised convention-over-configuration with Ruby on Rails. It remains widely used for web applications, developer tooling, and automation scripts. The YJIT compiler introduced in Ruby 3.1 significantly improved runtime performance.

Mon, 01 Jan 0001 00:00:00 +0000

Rust’s ownership model guarantees memory safety at compile time — no null pointers, no data races, no garbage collector. It’s the language behind many modern CLI tools, WebAssembly runtimes, and systems software.

Mon, 01 Jan 0001 00:00:00 +0000

SAS combines a procedural programming language with integrated statistical procedures for data management and analysis. It holds a dominant position in pharmaceutical clinical trials, banking risk analysis, and government statistics — sectors where regulatory requirements mandate validated, reproducible analysis environments. The SAS data step and PROC SQL remain foundational for millions of analysts.

Mon, 01 Jan 0001 00:00:00 +0000

Scala unifies object-oriented and functional programming on the JVM, with a powerful type system and expressive syntax. It became the dominant language for big data pipelines through Apache Spark and is used in high-throughput backend services at Twitter, LinkedIn, and Databricks. Scala 3 introduced significant improvements to the type system and syntax clarity.

Mon, 01 Jan 0001 00:00:00 +0000

Scheme distilled Lisp to a minimal core — first-class functions, proper tail calls, hygienic macros, and continuations — without sacrificing power. It is the language of Structure and Interpretation of Computer Programs (SICP), one of the most influential programming textbooks. R7RS is the current standard; implementations include Guile, Chez Scheme, and MIT Scheme.

Mon, 01 Jan 0001 00:00:00 +0000

Self pioneered prototype-based OOP, where objects are cloned and modified rather than instantiated from classes — an approach JavaScript later adopted. The Self VM pioneered adaptive optimisation and polymorphic inline caching, JIT techniques that became the foundation of modern JavaScript engines like V8 and SpiderMonkey. It remains an influential research language.

Mon, 01 Jan 0001 00:00:00 +0000

Simula was created by Ole-Johan Dahl and Kristen Nygaard at the Norwegian Computing Center to simulate discrete-event systems. It introduced the class concept, object instantiation, and inheritance — every OOP language from C++ to Java descends from Simula’s ideas. Bjarne Stroustrup cited Simula as the primary inspiration for C++.

Mon, 01 Jan 0001 00:00:00 +0000

Smalltalk pioneered the concepts of objects, message passing, garbage collection, and the live IDE environment where you modify running code. Every modern OOP language owes conceptual debt to Smalltalk. Pharo and Squeak keep the tradition alive, and Smalltalk remains widely used in finance and insurance at companies like JP Morgan.

Mon, 01 Jan 0001 00:00:00 +0000

Solidity compiles to EVM bytecode that runs on the Ethereum network and every EVM-compatible chain. Its syntax draws from JavaScript and C++, and it includes concepts specific to blockchain like payable functions, msg.sender, and require guards for access control. Security auditing is critical — bugs in deployed contracts are often irreversible.

Mon, 01 Jan 0001 00:00:00 +0000

SQL (Structured Query Language) is the standard interface to relational databases including PostgreSQL, MySQL, SQLite, and SQL Server. Its declarative style lets developers describe what data they need rather than how to retrieve it. SQL dialects power everything from OLTP transactions to analytical data warehouses like BigQuery, Snowflake, and Redshift.

Mon, 01 Jan 0001 00:00:00 +0000

Squirrel was designed as a scripting layer for the Source game engine at Valve and is used in Left 4 Dead, Portal 2, and Dota 2 for game logic, AI, and level scripting. Its C-like syntax, class system, and generator support make it approachable for game designers. It is also used in vehicle firmware (Tesla) and IoT scripting environments.

Mon, 01 Jan 0001 00:00:00 +0000

Standard ML was the first language to be formally specified with a mathematical semantics. Its Hindley-Milner type inference, module system, and pattern matching influenced Haskell, OCaml, F#, Rust, and Swift. MLton produces highly optimised native code; SML/NJ provides an interactive environment. It is widely used in compilers courses and PL research.

Mon, 01 Jan 0001 00:00:00 +0000

Swift was built to be faster and safer than Objective-C while remaining expressive and modern. Its optionals eliminate null pointer errors at compile time, and its protocol-oriented design encourages composable code. Beyond Apple platforms, Swift on Server (Vapor) is gaining adoption for high-performance HTTP services.

Mon, 01 Jan 0001 00:00:00 +0000

Tcl (Tool Command Language) paired with the Tk GUI toolkit was the first accessible cross-platform GUI toolkit for Unix, Windows, and macOS. It remains the scripting language embedded in electronic design automation tools (Cadence, Synopsys, Xilinx Vivado) and network devices. Expect, a Tcl extension, is the standard for automating interactive programs.

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript is a typed superset of JavaScript developed by Microsoft. It compiles to plain JavaScript and adds interfaces, generics, and a powerful type system that makes large applications maintainable.

Mon, 01 Jan 0001 00:00:00 +0000

Unison stores code by the hash of its abstract syntax tree rather than by name — renaming a function never breaks anything. This content-addressed model enables Unison Cloud, where functions are deployed to distributed nodes by their hash. Its ability type system tracks effects (IO, exceptions, state) as a first-class feature.

Mon, 01 Jan 0001 00:00:00 +0000

V (Vlang) compiles to C for portability and produces small native binaries without a garbage collector. It draws heavily on Go’s syntax and philosophy while adding features like sum types, optional types, and compile-time memory safety checks. The compiler itself is written in V and compiles in under a second.

Mon, 01 Jan 0001 00:00:00 +0000

Vale achieves memory safety through generational references — every allocation has a generation number, and pointer reads check the generation at runtime, catching use-after-free without requiring a borrow checker. This trades a small runtime overhead for dramatically simpler code compared to Rust. Vale is pre-1.0 and targeting game development and systems programming as primary domains.

Mon, 01 Jan 0001 00:00:00 +0000

VBA is embedded in every copy of Microsoft Office and remains the primary tool for automating complex Excel spreadsheets, Word document generation, and Access database workflows in enterprise environments. Despite its age, it processes billions of dollars in financial calculations daily through Excel macros that have run untouched for decades.

Mon, 01 Jan 0001 00:00:00 +0000

Verilog describes digital hardware at the register-transfer level — circuits are described as modules with inputs, outputs, and logic that executes concurrently. It is used to design CPUs, FPGAs, ASICs, and every other digital chip. SystemVerilog extends Verilog with object-oriented features for testbench development.

Mon, 01 Jan 0001 00:00:00 +0000

VHDL (VHSIC Hardware Description Language) was developed under a US Department of Defense initiative and is strongly typed compared to Verilog. Its verbosity makes intent explicit, which suits safety-critical military and aerospace applications. GHDL provides an open-source VHDL simulator; commercial tools from Xilinx and Intel/Altera support both Verilog and VHDL.

Mon, 01 Jan 0001 00:00:00 +0000

Visual Basic’s drag-and-drop form designer and approachable syntax made Windows application development accessible to non-specialists. VB.NET is the modern evolution running on .NET, fully interoperable with C#. Despite being eclipsed by C#, there are billions of lines of VB.NET in enterprise applications and Office add-ins that continue to run in production.

Mon, 01 Jan 0001 00:00:00 +0000

Wren is designed to be embedded in applications as a scripting layer — the core interpreter fits in a single C file. Its class-based OOP and concurrency via fibers are approachable for game designers and end users. Bob Nystrom, the author of Crafting Interpreters, wrote Wren, and the book documents many of the implementation techniques used in it.

Mon, 01 Jan 0001 00:00:00 +0000

Zig targets the same use cases as C — operating systems, embedded firmware, compilers — but with a design that eliminates undefined behaviour, makes allocations explicit, and provides powerful comptime metaprogramming without macros or templates. Zig can cross-compile C/C++ projects and is used as a drop-in C toolchain by projects like Bun and TigerBeetle.