Declaring

Attribute Routing

Learn how to declare routes directly on controllers and actions with attributes, and how this approach complements or replaces convention-based routing.

Cascading Parameters

Understand how CascadingValue and [CascadingParameter] let ancestor components implicitly supply data to deeply nested descendants without prop drilling.

Component Parameters

Learn how Blazor components accept and expose data from their parents using the [Parameter] attribute, including required parameters, complex types, and one-wa…

Task Dependencies

Learn how to wire tasks together with bitshift operators and the chain() helper, and how trigger rules control execution when upstream tasks fail or skip.

Sources and Freshness Checks

dbt sources let you declare and document raw, unmodeled tables loaded by upstream tools, and freshness checks automatically flag when that raw data has stopped…

Variables in Flows

How to declare, set, and accumulate values in flow-scoped variables, and where they go wrong inside loops.

Variables and Control Flow

Learn how T-SQL variables store scalar values inside a batch and how IF/ELSE and WHILE let you branch and loop through procedural logic.

Arrays in Fortran

Declaring, indexing, sectioning, and efficiently looping over Fortran's column-major arrays.

Derived Types

Learn how Fortran's TYPE construct lets you bundle related data of different kinds into a single named structure, and how to declare, initialize, and access it.

Multidimensional Arrays

How Fortran declares, stores, and loops over arrays with two or more dimensions, and why column-major order shapes fast code.

Parallel Programming with Coarrays

Learn how Fortran's native coarray feature enables SPMD parallel programming across multiple images without external message-passing libraries.

Arrays in Pascal

Learn how Pascal's fixed-size, strongly-typed arrays work, from simple index ranges to multidimensional matrices.

Generics in Free Pascal

Understand how Free Pascal's generic types and routines let you write reusable, type-safe containers and algorithms with `generic` and `specialize`.

Records in Pascal

Understand how Pascal records bundle fields of different types into a single structured entity, including variant records.

Apex Syntax and Variables

Covers the foundational rules of Apex syntax, how to declare and scope variables, naming conventions, and how comments structure readable code.

Arrays in Arduino

Store and manage collections of related values using arrays, and combine them with loops to control multiple pins efficiently.

VB.NET Syntax and Variables

Core VB.NET syntax rules — statements, case-insensitivity, variable declarations with Dim, naming conventions, scope, and comments.

Modules in Prolog

Learn how Prolog's module system namespaces predicates, controls visibility, and enables code reuse across larger logic programs.

Classes and Objects in Objective-C

How Objective-C classes are declared with @interface/@implementation, and how objects are created via alloc and init.

Objective-C Syntax and Variables

How Objective-C extends C syntax with object messaging, and how primitive versus object variables are declared.

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.

Namespaces and require

Learn how Clojure organizes code into namespaces and how ns, require, import, and refer control how symbols are loaded and referenced across files.

Units of Measure

See how F#'s units of measure attach compile-time-only physical units to numeric types, catching dimensional-analysis bugs before runtime.

Sequential File Processing

Learn how COBOL reads, writes, and updates records in a sequential file, the oldest and most common file organization in mainframe batch systems.