Index
All Topics
Every subject on the site, with a description of what it covers. Tags come from a controlled vocabulary, so the build fails on one that is not declared.
Null-Conditional Operator1
Conditional member or element access that stops evaluation when its receiver is null. Its use determines whether missing objects legitimately skip work or conceal a broken assumption.
Nullable Reference Types1
C# annotations and compiler analysis that describe whether references may be null. Initialization, flow analysis and warning suppression determine the promises expressed in source code without adding runtime null checks.
Message Brokers2
Infrastructure that receives, routes and delivers messages between applications. Publisher and subscriber contracts, message properties, acknowledgements and delivery guarantees determine how applications use a broker.
Expression Trees1
Representing code as a tree of expressions that a program can inspect, transform or translate. C# can convert supported lambdas into expression trees, exposing their parameters, member accesses and operations without executing the lambda.
Dependency Inversion1
Arranging source dependencies so application policy and implementation details meet through abstractions that are independent of those details. Implementations conform to the contracts rather than requiring policy to depend on concrete infrastructure.
CPU Caches1
Processor caches retain nearby copies of instructions and data. Cache lines, locality, sharing and coherence affect the cost of accessing a program's working set.
One-to-Many Mapping1
Associating one key with multiple values while defining which keys each value may belong to. Lookup direction, uniqueness constraints and update rules determine the relationship's contract and storage.
Adapter Pattern3
Translating an existing component's interface into the interface its caller needs. The adapter owns the translation while keeping the underlying component's API details inside its implementation.
Anonymous Types1
Compiler-generated types created from property names and values without an explicit class declaration. Their inferred identity, read-only properties and value-based equality shape their use in local operations and query projections.
Autonomous Methods1
Methods that operate on information supplied through their signatures without depending on changing state accumulated by their class. They may use fixed information and perform external side effects, distinguishing autonomy from purity.
Boxing1
Representing a value-type value inside an object so it can be used through an object or interface reference. Boxing and unboxing affect copying, allocation and the behavior of typed and untyped APIs.
Caching1
Retaining results or reusable resources to avoid repeating work. Ownership, validity, retention limits and lifetime determine when cached state can safely be reused.
Compilation7
Translating source code or intermediate instructions into executable code and metadata. Compiler transformations, specialization and code sharing determine what is produced before deployment or during execution.
Constants1
Values fixed at compile time and substituted where code uses them. Their declarations, permitted expressions, and treatment across assembly boundaries determine how changes reach consumers.
Constructors1
How objects are initialized through constructor bodies, field initializers, and calls between constructors. Inheritance and virtual dispatch determine which state is available while construction proceeds.
Deconstruction1
Extracting individual values from tuples or objects into separate variables. C# supports positional tuple extraction and Deconstruct methods, including overloads, extension methods and discarded results.
Garbage Collection1
Automatically reclaiming storage occupied by objects that are no longer reachable. Allocation volume, object lifetimes and surviving references affect collection frequency, memory use and execution costs.
Generics1
Types and methods parameterized by other types. Compiler and runtime support determine how type arguments are checked, retained and used to specialize or share executable code.
Hash Sets2
Collections of distinct values organized for hash-based membership checks. Equality comparers, mutation and set operations determine their behavior and the work required for lookups.
Higher Order Functions1
Functions that accept other functions as arguments, return functions, or both. Passing behavior lets a reusable algorithm delegate particular decisions to its caller.
Immutability4
Keeping a value or object's contents unchanged after creation. Operations produce replacement values, while variables may still be reassigned to refer to those replacements.
Lambdas2
Expressions that define anonymous functions where behavior is needed. Parameter inference, statement and expression bodies, captured variables and the required target type determine how they are used.
Memory Allocation4
Obtaining storage for values, objects and working data. Allocation size, frequency and lifetime affect copying, memory use and the work required to reclaim storage.
Object Layout2
How a runtime represents objects through field storage, headers and references to shared type information. Layout and allocation overhead depend on the runtime and target architecture.
Optional Parameters1
Method parameters with defaults that allow callers to omit corresponding arguments. Binding, overload selection, and the placement of default values affect API use and changes to existing callers.
Parameter Passing1
How method parameters receive argument values or access caller variables. Passing by value and passing by reference determine what is copied and which assignments can affect the caller.
Static Classes2
Classes whose members are used without constructing instances. Their language constraints, shared state and responsibilities determine when they suit a design.
Static Initialization1
Establishing a type's static state through field initializers and static constructors. Runtime timing guarantees and initialization failures determine what subsequent uses of the type can rely on.
String Concatenation2
Combining strings into a single result. Fixed expressions, repeated concatenation, formatting and compiler transformations determine the intermediate values, copying and allocations involved.
StringBuilder1
The .NET type for accumulating characters in mutable construction storage before producing a string. Append operations, capacity, chunk growth and final copying determine its behavior and costs.
Value and Reference Types3
The distinction between variables containing values directly and variables containing references to objects. Field storage, assignment and copying determine how values and shared objects behave.
Value Tuples1
Grouping values into positional elements using .NET ValueTuple types and C# tuple syntax. Element names, assignment, copying, mutation and equality determine how these groups behave.
Try-Parse1
The Try-Parse pattern gives parsing a Boolean answer for defined invalid-input outcomes. Other failures still throw, and callers requiring the result can use the corresponding throwing operation.
Progress Reporting3
Reporting the steps, completed work, and elapsed time of a running operation through stable run, item, and step identifiers. Completion events describe work that actually finished, so operators can distinguish progress, stalls, and failures.
Structured Logging4
Structured logging records named properties alongside an event so people and tools can filter, correlate, and investigate failures without parsing message text.
Architecture11
How a system is divided into layers, where each responsibility belongs, and what may legitimately depend on what.
Naming6
Choosing names that state what a thing is, and keeping those names stable as a value moves through a system.
Method Design14
Visibility, return contracts, abstraction levels, and the difference between a method that acts and one that answers.
Class Design13
Separating behavior from state, deciding what may be inherited, and keeping types honest about what they hold.
Testing8
Which layer proves what, how tests are arranged, and what a passing test is actually evidence of.
Acceptance Testing22
Exercising a system through its front door as a black box, with attention to where test data comes from and what keeps a scenario true over time.
Error Handling18
Treating failure as a designed path: validation at boundaries, exception translation, and what a caught exception obliges you to do.
Data Access11
Reaching a store without letting its shape leak upward. Language-independent guidance, currently illustrated in Python.
Applied AI Engineering7
Designing, implementing and evaluating applications that use AI models. Workflow control, bounded model judgments and verification determine how model contributions become reliable application behavior.
LLM Systems3
Designing processors, engines, and gateways that call language models, and keeping that machinery testable.
Python12
Material specific to Python, or illustrated with Python examples.
C#93
Material specific to C#, or illustrated with C# examples.
TypeScript0
Material specific to TypeScript, including this site’s own build.
AI-Assisted Development2
Working with coding agents: what to delegate, how to review the result, and where the failure modes cluster.
Prompting3
Writing instructions that define a language model's task, constraints, evidence requirements, and expected output. Prompt comparisons examine which decisions are specified and which remain open.
Verified, Not Trusted5
Evidence and reproducible checks for AI-generated claims, with explicit limits on what has been established and what remains uncertain.
Verification14
Establishing that required work actually happened, rather than accepting a confident report that it did. Coverage, completion, and what evidence supports a claim.
Agent Orchestration1
Coordinating multiple model workers: who decides what, what each one may see, what runs concurrently, and what stops a run.
Code Review5
Turning written guidance into rules a reviewer can apply consistently, by machine or by hand.
Public Surface7
The set of types a component exposes to its callers. Everything a caller can receive, pass or must catch belongs on it, and everything else stays internal, so the interior can change without breaking anyone.
Levels of Abstraction4
Arranging classes by altitude, so each level states what happens and delegates how to the level below. A class’s depth in the folder tree shows its level, and dependencies run one level down.
Service Interface Layer4
The thin host layer, such as a web API, CLI, worker or cloud function, that connects the outside world to a system. It translates transport input and forwards it to the domain, which must not depend on the host.
Design Patterns20
Named software design patterns such as Factory, Factory Method, Strategy, Template Method, and Iterator. Articles explain a pattern’s structure or apply it in a worked design.
Architectural Patterns22
Recurring structures for system responsibilities and boundaries, including Domain Facades, Service Locators, Gateways, Data Managers, and Configuration Providers.
AI Workflow Patterns6
Reusable ways to coordinate model judgments with code, including fan-out, confidence gates, composite scoring, and intent routing.
Domain Facade10
The single public entry point to a domain. It holds no logic of its own, forwards each business operation to a Manager, and hides every internal layer from callers.
Service Locator5
A narrow factory that creates only what must be swappable, such as configuration, loggers and transport handlers, so tests can substitute them. Only the Manager uses it, and only during construction.
Configuration Provider8
A typed wrapper over raw configuration that reads and validates settings eagerly and returns typed settings objects. Only the Manager uses it, and it passes values downstream, never the provider.
Gateway Pattern13
A domain-owned boundary to an external service. It presents business-shaped operations and models, and keeps provider types, resource models and failure translation behind it as one deletable unit.
Data Manager8
The component that owns a domain’s whole conversation with a data store. It presents business-shaped operations and keeps store technology, command construction and fault translation behind its seam.
Strategy Pattern1
Selecting one of several interchangeable behaviors through a common role.
Delegates6
Using C# delegates to pass behavior and compare that choice with named strategy classes.
Composition Over Inheritance7
Building capabilities from collaborating objects while keeping inheritance narrow and deliberate.
Dependency Injection2
Passing collaborators into objects and deciding which dependencies callers should control.
Factory Pattern8
Creating the right implementation behind a focused construction boundary.
Factory Method1
A creation hook on a consumer base class that subclasses override to choose a dependency from another class family.
Polymorphism8
Using a shared contract to work with different implementations without making callers name their concrete types.
Library Boundaries6
Contracts that let a system request capabilities in its own terms while containing a library’s calls, types, and failure conventions.
Model Design5
Defining data types so required fields, genuine absence, and distinct variants are clear to consumers.
Template Method2
Defining an operation in a base type while subclasses provide selected steps.
Extension Methods1
C# methods called as if they belong to a type, and their effect on discoverability and meaning.
Data Transfer Objects1
Immutable data carriers that keep state separate from the behavior operating on it.
Type Casting2
Choosing casts and type checks according to whether a mismatch is expected or a defect.
Mocking4
Replacing collaborators in tests and evaluating the effect on coupling and regression coverage.
Test Driven Development3
Using tests to establish behavior before implementation and preserving them through design changes.
Interfaces1
C# interface roles, their costs, and when a consumer needs a narrow capability.
Interface Segregation2
Presenting each consumer with only the operations it needs.
Boundary Validation7
Checking untrusted input and output at system boundaries while keeping internal flows clear.
Async and Await2
C# language features for suspending asynchronous methods and resuming them when awaited work completes.
Asynchronous I/O3
Waiting for files, databases, or network operations without keeping a caller thread blocked for the duration.
Task Composition4
Combining asynchronous operations so independent tasks can overlap and callers can handle their completion and results.
Load Testing1
Measuring throughput, latency, resource use, and dependency capacity as concurrent demand changes.
IIS5
Microsoft's web-server architecture for receiving HTTP requests, routing them to application pools, running application code in worker processes, and caching eligible responses.
Async Streams1
Asynchronous sequences that let a consumer await each item as it becomes available, including iterator creation, enumeration, cancellation, and resource lifetime.
Benchmarking12
Measuring an operation under controlled conditions and interpreting elapsed time, allocations, and other resource costs in light of the workload and implementations compared.
Iterator Pattern2
Traversing a sequence one item at a time through a stable iteration contract, with the consumer requesting each next item.
Jev4
TypeSafe AI’s System One model for typed judgments about supplied text. Choice, Score, and Noul support bounded semantic decisions.
Model Evaluation3
Measuring model decisions on representative labeled cases, including error costs, calibration, thresholds, abstention, and performance after changes.
Speculative Fan-Out1
Asking independent questions about shared state in one request, including answers that some later routes will not use.
Confidence-Gated Routing2
Using a model’s answer and tested confidence thresholds to choose between automatic action, another process, and human review.
Composite Scoring1
Scoring separate semantic dimensions and combining them with explicit weights to support a decision.
Intent Routing1
Classifying a request’s intent to choose a handler, such as ordinary code, a specialist model, or a person.
Context Compaction1
Reducing the material supplied to a language model by selecting relevant source units or summarizing them. Retention decisions must account for current goals, unique evidence, and information that later questions may need.
Test Mediator5
A testing pattern that carries scenario instructions to observation points and exposes captured results to assertions. It can remain separate from its spies or contain one service's private spy; it is distinct from the GoF Mediator pattern.
Transport Spy5
A test observation point at a transport boundary that records outgoing requests or incoming responses while retaining production behavior above that boundary. It can follow scenario instructions to forward, redirect, or supply a controlled response.
Builder Pattern4
Constructing a model through explicit configuration steps before producing the completed value. Test builders can supply reusable defaults while keeping each scenario's defining values visible and independently owned.
Idempotency1
Defining and verifying the outcome of repeated requests without repeating work that has already been accepted. Request identity, conflicting content, preserved state, and outstanding recovery obligations determine the contract.
Concurrency3
Behavior when operations overlap and contend for shared state or resources. Verification considers allowed outcomes, arbitration, duplicate effects, and the schedules a particular arrangement actually exercises.
Refactoring3
Changing internal organization while preserving established observable behavior. Stable public boundaries and maintained comparisons provide evidence that the reorganization preserves required outcomes.
Regression Testing2
Continuing to verify previously established behavior as later changes enter a system. Maintained scenarios preserve approved requirements and incorporate discovered defects so future runs check those lessons again.
Executable Documentation1
Documentation whose scenarios execute production behavior and check the outcomes they describe. Readers can connect requirements to the current implementation by running and debugging maintained tests.
Requirements Traceability1
Maintaining explicit connections from established requirements to scenarios, expected outcomes, observations, and comparisons. Those connections let reviewers identify missing coverage and distinguish behavioral evidence from structural review.
Test Isolation5
Keeping records, observations, configuration, and cleanup owned by the test or run that creates them. Isolation lets concurrent developers and CI jobs use infrastructure without consuming, altering, or deleting one another's state.
LocalDB1
SQL Server LocalDB instances for local applications and automated tests, including instance creation, connection strings, and database deployment.
Continuous Integration2
Automating builds and tests as changes enter a shared codebase, including build definitions, prerequisite setup, and repeatable execution environments.
Azure2
Deploying and operating applications on Microsoft Azure, including service configuration, role startup, storage, and execution environments.
Windows Impersonation1
Executing work under a different Windows identity through logon tokens and impersonation contexts, including privileges and identity lifetime.
MSMQ1
Microsoft Message Queuing for passing work between processes through local or remote queues, including installation and queue-based processing.
Background Processing1
Moving work beyond the initiating request into another execution context, with explicit handoff, processing responsibilities, and completion behavior.
REST6
Designing and consuming resource-oriented HTTP APIs through resource identifiers, method semantics, representations, and response status codes.
Cross-Origin Resource Sharing1
The HTTP mechanism through which a server permits browser requests from another origin, including origin headers, preflight requests, and allowed methods or headers.
jQuery3
Using jQuery to work with browser elements, events, attached data, and Ajax requests.
HTTP Method Override2
Carrying an intended HTTP method in a header on another request method, then translating it before dispatch to an application handler.
JavaScript5
Material specific to JavaScript, or illustrated with JavaScript examples.
JSON3
Representing structured data with JSON and converting between JSON text and application objects, including serialization and response handling.
HttpClient2
The .NET HttpClient API for sending HTTP requests and consuming responses, including request content, headers, asynchronous calls, and typed data conversion.
JSONP1
Returning JSON inside a JavaScript callback so browser clients can consume script responses across origins, including callback selection and endpoint exposure.
Self-Hosting1
Running a network service inside an application's own process, with explicit listener configuration, routing, startup, and lifetime management.
Quartz for ASP.NET1
Shiv Kumar's ASP.NET page-composition framework, where Builders assemble view objects and HTML templates into dynamic pages.
HTML Templates1
Reusable HTML structures whose placeholders receive application data or rendered views, including template selection and separation from rendering code.
ASP.NET WebForms1
Building and configuring ASP.NET WebForms applications, including application startup, project structure, and integration with HTTP services.
Roslyn1
The .NET compiler platform exposes syntax trees, symbols, and semantic information for tools that inspect, transform, or generate source code.
Syntax Highlighting1
Classifying source-code tokens and rendering them with distinct visual styles, including the relationship between syntactic structure and semantic information.
Visitor Pattern1
Applying operations while visiting elements of an object structure, with separate handling for the kinds of elements encountered.
Connected Devices1
Physical devices connected to computers or networks, with software interfaces that let applications read their state or control their behavior.
Sandboxing1
Restricting an application's access to system resources and exposing permitted capabilities through controlled interfaces and permissions.
WCF2
Windows Communication Foundation services and clients, including contracts, transport bindings, endpoints, hosting, metadata exchange, and diagnostics.
Service Proxies1
Client-side objects that expose a remote service's operations and translate local calls into messages sent through a transport.
ASP.NET10
Building web applications with ASP.NET, including request processing, handlers, controllers, responses, and framework behavior.
HTTP3
HTTP request and response behavior, including methods, headers, connections, content, and client-server communication.
Asynchronous Programming Model2
The .NET Asynchronous Programming Model exposes Begin and End method pairs, IAsyncResult, callbacks, and state for asynchronous operations.
LINQ5
Language Integrated Query operations over data, including filtering, projection, joins, grouping, and the relationship between query and method syntax.
Parallel Programming1
Dividing computational work so multiple processors or cores execute it at the same time, with attention to partitioning, scheduling, synchronization, and overhead.
WMI1
Windows Management Instrumentation exposes management information about Windows systems through queryable classes and properties.
CPU Hardware2
Processor characteristics such as physical packages, cores, logical processors, instruction-set architecture, and address width.
URL Encoding1
Representing data in URL components through percent encoding, with attention to reserved characters, unreserved characters, and form-encoding conventions.
Windows Services1
Background services managed by Windows, including service discovery, lifecycle commands, status changes, and programmatic control.
Process Management1
Launching and controlling operating-system processes, collecting standard output and errors, waiting for completion, and interpreting exit status.
SQL Server2
Microsoft SQL Server databases, including SQL commands, storage features, administration, and application integration.
Identity Columns1
Database columns whose numeric values are generated from a seed and increment, including how insertion and reseeding affect subsequent values.
Duplicate Detection1
Finding repeated values or records under an explicitly chosen comparison key, including grouping matches and retaining the records that share that key.
Serialization1
Converting objects and sequences into representations that can be stored or transmitted, and reconstructing values from those representations. Contracts determine member names, data shape, and stream handling.
DataReaders3
Reading result sets sequentially through ADO.NET DataReaders. Typed wrappers, connection lifetime, and the choice between streaming rows and materializing objects shape their use.
Debugging2
Investigating unexpected application behavior with diagnostic tools, traces, and observed execution to identify its cause.
Web Performance1
How quickly websites deliver responses and become usable in a browser. Server processing, transferred resources, caching, and measurement all contribute to the result.
Blogging2
The tools and workflows for writing, editing, and publishing blog posts, including blog engines and their authoring interfaces.
MetaWeblog API1
An XML-RPC interface for creating and editing blog posts, retrieving categories, and uploading media. Blog engines implement its operations so compatible authoring clients can publish to them.
Code Generation3
Producing source code from metadata, models, or templates. Generators turn a repeatable structure into code while keeping the inputs and generated responsibilities explicit.
ADO.NET2
.NET data-access APIs for connections, commands, parameters, readers, adapters, and in-memory tables. Provider abstractions support working with different database engines.
Stored Procedures3
Named database operations that accept parameters and execute commands close to the stored data. Their result sets and parameters provide contracts for application data access.
OAuth1
Delegating access to protected resources through provider-issued credentials and tokens. Applications follow an authorization flow and use the resulting access token for permitted requests.
Reflection2
Inspecting types and members at runtime and invoking capabilities that are not fixed in the calling code. In .NET, reflection also supports generating executable methods through Reflection.Emit.
Request Binding1
Mapping HTTP form fields and query parameters into typed values or objects. Binders define conversion, defaults, and how multiple incoming fields populate a model.
Type Conversion1
Transforming a value from one representation or data type into another, including parsing text, handling numeric formats, and converting collections or custom objects.
Razor2
Razor combines C# expressions and control flow with text templates. It supports ASP.NET views and layouts as well as hosted template generation outside a web application.
Model-View-Controller2
An application structure that separates models, presentation, and the controllers coordinating interactions. Implementations determine how data and control pass between those roles.
File Upload1
Transferring files from clients to servers, including file selection, multipart requests, progress feedback, and completion or failure handling.
XMLHttpRequest1
The browser API for sending HTTP requests and receiving responses from scripts, including request bodies, upload events, and asynchronous completion.
Web Browsers2
Browser behavior, standards support, performance, and the controls people use to navigate and interact with websites.
User Interface Design1
Arranging controls, content, navigation, and feedback around the tasks people need to perform.
Flash Player3
Adobe's historical runtime for browser multimedia and interactive content, including video playback, SWF execution, and desktop or mobile integration.
Video Codecs2
Video encoding and decoding formats, including their compression, picture quality, playback support, and hardware requirements.
HTTP Range Requests1
HTTP requests for selected portions of a resource, supporting partial downloads and seeking within media without transferring the entire file first.
Home Theater PC1
Using a general-purpose computer with a television and audio system for media playback, browsing, and applications, including display connections and remote input.
Online Video1
Delivering and watching video over the Internet, including picture quality, bandwidth, playback devices, and viewing experience.
HTML5 Video3
Native video playback through the HTML video element, including controls, poster images, browser behavior, and supported media formats.
Video Posters1
Representative images shown before video playback, including frame selection, custom thumbnails, and their presentation in video players.
HTML Parsing1
Reading HTML as a document structure to select elements and extract text, attributes, links, and other information.
HtmlAgilityPack1
A .NET library for loading and parsing HTML documents, navigating their nodes, and extracting information with selectors such as XPath.
H.2641
The AVC video coding standard, including compression and playback characteristics, implementation support, and licensing distinctions.
CSS1
Stylesheets that control web presentation, including layout, positioning, overflow, colors, typography, and visual states.
FTP1
The File Transfer Protocol and its server configuration, including user access, directory isolation, and file-transfer permissions.
Authentication1
Establishing the identity of a user or client through credentials and configured identity providers before granting access.
ASP.NET Web API6
The ASP.NET Web API framework for HTTP services, including ApiController routing, hosting, message handlers, formatters, and response construction.