D (programming language)

D (programming language)
D Programming Language contributors · Public domain · source
Paradigm	Multi-paradigm: imperative, object-oriented, generic, functional, metaprogramming
Designer	Walter Bright, Andrei Alexandrescu
Developer	Digital Mars, D Language Foundation
Typing	Static, inferred
Influenced by	C, C++, Java, Eiffel, Ada, Smalltalk, Algol, Modula-2, ML, Haskell, Python
Influenced	Swift, Rust, Zig, Vala
First appeared	2001
Latest release	2.103.0
License	Boost Software License, Apache License 2.0
Website	dlang.org

D (programming language) is a systems programming language combining performance-oriented features of C and C++ with modern constructs from Java, Python, Haskell, and Ada. Designed for high-performance applications, it emphasizes metaprogramming, memory safety options, and pragmatic tooling to support software engineering tasks across domains such as systems, games, finance, and scientific computing. The language balances low-level control with high-level abstractions to enable both micro-optimizations and large-scale software architecture.

Overview

D originated as a successor to C++ ideas while drawing on influences from Algol, Modula-2, Smalltalk, Eiffel, ML, and Haskell. It supports static typing with type inference, object-oriented programming reminiscent of Smalltalk and Java, and template/metaprogramming inspired by C++ and Ada. Concurrency models in D permit shared-memory and message-passing styles that echo patterns from Erlang and Go. Tooling and ecosystem efforts have involved organizations like Digital Mars and the D Language Foundation.

History and Development

D's design began under Walter Bright at Digital Mars and later evolved with contributions from Andrei Alexandrescu, who brought ideas from C++ template metaprogramming and Design by Contract practices from Eiffel. Key milestones parallel events such as the publication of Alexandrescu's work and community governance moves similar to those seen in projects like Python and Ruby. The language transitioned through versions reflecting community input in processes resembling the evolution of LLVM and GCC-based toolchains. Stewardship has involved foundations analogous to the Apache Software Foundation and collaborations resembling those between Mozilla Foundation and assemblages of corporate and academic contributors.

Language Features

D provides systems-level features like manual memory management and deterministic destructors similar to C++'s RAII, and optional garbage collection resembling implementations in Java and C#. Its compile-time function execution and compile-time reflection echo metaprogramming techniques from Template Haskell and C++ templates, while mixins and string-based code generation recall approaches used in Lisp macros and Python metaprogramming. Modules and interfaces are influenced by Java and C#, while tuple and functional-style features parallel constructs in Haskell and Scala. D's unit testing and contract programming features are comparable to those found in Eiffel and NUnit-style frameworks. Error handling incorporates patterns seen in Go's error returns and Rust's Result types via libraries.

Standard Library and Tooling

The standard library, Phobos, offers containers, algorithms, threading, and I/O facilities analogous to libraries in Boost, STL, Qt, and Java Standard Library. Build systems and package managers in the ecosystem mirror tools like CMake, Bazel, Cargo, and Maven in terms of dependency management and build reproducibility. Debuggers and profiling workflows integrate with tools such as GDB, LLDB, and Valgrind; IDE support has been developed through extensions similar to those for Visual Studio Code, Eclipse, and IntelliJ IDEA. Continuous integration and deployment patterns follow conventions established by platforms like Jenkins, Travis CI, and GitHub Actions.

Implementations and Compilers

Primary compiler implementations include DMD by Digital Mars, LDC leveraging LLVM, and GDC based on GCC, reflecting strategies similar to Clang and GCC front-ends. Backends enable interoperability with native toolchains on platforms such as Linux, Windows, macOS, as well as embedded targets exemplified by ARM and RISC-V. Cross-compilation and linking interact with system libraries like glibc, musl, and platform SDKs similar to those used for Android and iOS development. Compiler diagnostics, optimization passes, and code generation draw on techniques familiar from LLVM and GCC projects.

Adoption and Use Cases

D has been used in areas including systems programming, game development, high-frequency trading, and scientific computing, paralleling adoption patterns of C++, Rust, and Go. Notable domains include engine development like those built with Unreal Engine and Unity-adjacent toolchains, low-latency trading infrastructures akin to architectures used at Jane Street and Goldman Sachs, and numerical libraries comparable to BLAS and LAPACK. Academic and research groups with interests similar to those at MIT, Stanford University, ETH Zurich, and Max Planck Institute have explored language features for program correctness and performance. Commercial adopters mirror the diversity of firms leveraging C# or Java ecosystems.

Criticism and Limitations

Criticisms of D echo concerns raised about languages like C++ and JavaScript: fragmentation among compiler implementations similar to early ECMAScript implementations, ecosystem maturity compared with Rust's Cargo or Python's PyPI, and learning curve issues akin to C++ template metaprogramming. Interoperability with major platform ecosystems can be more arduous than with languages backed by corporations like Microsoft or Google, leading to slower corporate adoption similar to challenges faced by Haskell and OCaml. Tooling variance and limited vendor backing have led some projects to favor alternatives such as Rust, Go, C++, or Zig.

Category:Programming languages