DProgramming Study Notes

Arrays and Slices in D

How D's static arrays, dynamic arrays, and slices differ in memory ownership, mutation, and performance, and how to use them correctly.

BetterC and Systems Programming

The -betterC compiler switch strips D down to a GC-free, runtime-minimal subset ideal for embedded, kernel, and other systems-programming contexts where a full…

Building a CLI Tool in D

A hands-on walkthrough of building a command-line tool in D: parsing arguments with std.getopt, handling files and errors safely, and packaging a release binar…

Classes in D

How D's reference-type classes work: single inheritance, polymorphism, the Object root, and construction/destruction lifecycle.

Compile-Time Function Execution (CTFE)

Understand how D executes ordinary functions at compile time to compute constants, validate data, and generate code before the program ever runs.

Concurrency in D

Explore D's message-passing actors in std.concurrency, shared-memory safety via shared/synchronized/immutable, and declarative data parallelism with std.parall…

Conditionals in D

Learn how D Programming handles branching logic with if-else, switch, the ternary operator, and compile-time static if.

D and C Interop

How D's native extern(C) linkage lets you call existing C libraries directly and expose D functions to C code without writing wrapper glue.

D Best Practices

Practical conventions for writing idiomatic, maintainable D: default immutability, range-based pipelines, deliberate GC management, and design-by-contract test…

D for High-Performance Computing

D combines low-level control -- @nogc code, SIMD intrinsics, and manual memory layout -- with high-level expressiveness, making it a practical choice for numer…

D Interview Questions

The concepts D interviewers actually probe: struct vs class semantics, the function attribute system, template constraints, and the actor-model concurrency of…

D Operators and Expressions

How D's arithmetic, comparison, logical, and special operators like ^^, .., and is work, with a focus on gotchas like integer division.

D Quick Reference

A condensed lookup of D's core syntax — variables, arrays, functions, templates, control flow, and the most commonly used Phobos standard library modules.

D Variables and Types

A tour of D's built-in types, type inference with auto, const versus immutable, and how arrays and strings work under the hood.

D vs C++

A practical comparison of D and C++ covering memory management, compile-time metaprogramming, syntax safety, and tooling to help you decide when D is the bette…

Delegates and Closures

Understand D's delegate type, how closures capture context, and how delegates power callbacks and higher-order functions.

DUB Package Management

DUB is D's official build tool and package manager -- it resolves dependencies, drives builds across configurations, and publishes reusable packages to the DUB…

Error Handling in D

Learn D's split between recoverable Exceptions and unrecoverable Errors, the scope(exit)/failure/success guards, and std.exception helpers like enforce and not…

Functions in D

Understand D function declarations, parameter storage classes (in/ref/out/lazy), overloading, and Design by Contract.

Garbage Collection in D

How D's built-in conservative garbage collector manages class instances, dynamic arrays, and closures, and how to control or work around it.

Installing D and DUB

Step-by-step guide to installing a D compiler (DMD, LDC, or GDC) and DUB, D's package and build manager, on any platform.

Loops in D

Master D's looping constructs -- while, do-while, for, foreach, and foreach_reverse -- including range iteration and loop control.

Manual Memory Management in D

How to opt out of D's garbage collector using malloc/free, std.experimental.allocator, and struct-based RAII for deterministic, low-latency memory control.

Mixins and Metaprogramming

See how D's string mixins and template mixins let you generate and reuse code at compile time, powered by CTFE and compile-time reflection via __traits.