Skip to main content

Glossary of Terms

This document provides definitions for recurring terms, tools, and patterns used in the WepNG_MVC architectural analysis and evolution.

General Terms​

Hot Path​

A code path (method, loop, query) that is executed with very high frequency (e.g., thousands of times per second) or is part of a critical user interactivity loop.

  • Why it matters: In a Hot Path, even micro-optimizations (like avoiding string allocation) matter. In a "Cold Path" (run once a day), they are irrelevant.
  • Example: A loop iterating over 50,000 prices to calculate a discount vs. a one-time script sending a "Reset Password" email.
  • Detection: Identified via Profilers (Application Insights, MiniProfiler, DotTrace) showing high CPU time or high Call Count.

Cold Path​

Code providing auxiliary functionality or rarely executed (e.g., startup logic, error handlers, admin configurations). Optimization here is often "Premature Optimization".

Business Rule (BR)​

A specific, testable constraint or logic statement that defines how the business operates.

  • Format: BR-[Module]-[Number] (e.g., BR-OMGT-001).
  • Context: Used to decouple "Policy" from "Code". Business Rules should be validated in Domain Entities or Services, never in Controllers.
  • Storage: Defined in Business Rule Index or embedded in Use Cases/Gherkin.

Workflow Bar​

The UI component displaying the status of various sub-workflows (contexts) for an order, such as Travel, Placement, and Interview.

  • Context: Visualizes the Activity Based Workflow.
  • Synonyms: Context Bar.

Modular Monolith​

An architectural pattern where code is organized into loosely coupled, logically independent modules within a single deployment unit (one application).

  • Context: Chosen for WepNG to achieve clean boundaries without the distributed complexity of Microservices.
  • Benefit: easier testing, single transaction capability for OMGT, and clear path to future extraction.

Tools & Frameworks​

.NET 8​

The modern, high-performance, cross-platform successor to .NET Core. It is the target platform for WepNG's modernization and new services.

  • Context: Used for new "Headless" modules and performance-critical services.
  • Link: .NET 8 Documentation

.NET Framework 4.8​

The last major version of the legacy .NET Framework.

  • Context: The current platform for the WepNG_MVC monolith. Requires maintenance until the full Strangler Fig migration is complete.
  • Link: .NET Framework 4.8 Documentation

.NET Standard 2.1 library​

A formal specification of .NET APIs that are intended to be available on all .NET implementations.

  • Context: Used for shared libraries (e.g., Domain models, Common utilities) that need to be compatible with both modern .NET (8+) and .NET Core 3.0+.
  • Link: .NET Standard

Garbage Collector (GC)​

Automatic memory management feature in .NET that allocates and releases memory for an application. It reclaims memory occupied by objects that are no longer in use.

  • Context: High "GC Pressure" is a key performance indicator, often caused by String Concatenation in Loops or excessive object allocation.

Gherkin​

A Business-Readable, Domain-Specific Language (DSL) used to describe software behavior without detailing how that behavior is implemented. It serves as "Living Documentation" and an automated testing script.

Kendo UI for MVC​

A set of server-side wrappers for the Kendo UI jQuery widgets, heavily used in WepNG for complex Grids and Forms.

  • Constraint: Creates a "Kendo Trap" (lock-in) because business logic (filtering/sorting) is tightly coupled to the server-side DataSourceRequest.
  • Evolution: Postponed for core OMGT; new features use React-based alternatives.

LLBLGen Pro v4.2​

An Entity Framework and ORM modeling tool used to generate the Data Access Layer code in this project.

  • Context: Used to generate WEPV2ModelBuilder.cs.
  • Constraint: Code generated by this tool should generally NOT be modified manually.
  • Link: Official Site

MiniProfiler​

A simple but effective library for profiling ASP.NET MVC applications. Used to detect performance issues like N+1 queries.

TFM (Target Framework Moniker)​

A standardized token used in .NET project files to specify the target platform and API set.

  • Examples: net8.0, net48, netstandard2.1.
  • Context: Essential for managing multi-targeting and library compatibility across the monolithic and modern parts of the ecosystem.
  • Link: Target Frameworks in SDK-style projects

Transition Table​

A matrix used to document Valid State Transitions in a workflow.

  • Components: Current State, Actor, Action, Next State, Side Effects.
  • Context: Essential for documenting Process Workflows (e.g., Request Lifecycles) where the behavior depends on the entity's current state.
  • Links:

Use Case​

A text-based description of a human-computer interaction, focusing on the user's goal and the system's response.

  • Format: We use the "Cockburn Fully Dressed Lite" format.
  • Context: Used to document Human Workflows (Explicit Tasks) and UI interactions.
  • Constraint: Must describe "User Intention" rather than UI mechanics.
  • Links:

Zoho Analytics​

A cloud-based Business Intelligence (BI) and analytics platform.

  • Context: Target for the "Embedded BI" extraction. Used to host the WEP BudgetContracts and reporting dashboards.

Architectural Patterns​

Strangler Fig Pattern​

A migration strategy for legacy systems where the new system is built around the edges of the old one, gradually replacing it until the old system can be "strangled" (retired).

Side-car Pattern (Logic Side-car)​

An architectural pattern where new business logic is deployed as a separate, isolated component (Side-car) alongside the legacy application, rather than modifying the core monolith.

  • Context: Used in WepNG Modernization (e.g., OrderPriorityService) to implement complex algorithms (Side-car) that read from the Monolith's database but maintain zero state and zero code coupling.
  • Goal: Facilitates TDD, safe experimentation, and eventual extraction to Microservices.
  • Link: Logic Side-car

Reverse Proxy​

A server that sits in front of web servers and forwards client requests to those web servers.

  • Role in WepNG: Acts as the "Ingress" for the Strangler Fig pattern, routing requests to either the Legacy Monolith or the Modern API.
  • Implementation: YARP (Modern .NET) or ARR (Legacy IIS).

YARP (Yet Another Reverse Proxy)​

A library to help create reverse proxy servers that are high-performance, production-ready, and highly customizable.

  • Context: Used in WepNG to route traffic between .NET 4.8 and .NET 8.
  • Link: YARP Documentation

ARR (Application Request Routing)​

A proxy-based routing module for IIS.

  • Context: Legacy option for request routing in the Strangler Fig pattern.

DTO (Data Transfer Object)​

An object that carries data between processes (or layers). The motivation for its use is that communication between processes is usually done resorting to remote interfaces (e.g., Web Services), where each call is an expensive operation.

  • Context: Used to decouple Domain Entities (EF) from the View (MVC) or API response, avoiding serialization issues (loops) and over-fetching.
  • Link: Martin Fowler: DTO

Independent Contexts (Bounded Contexts)​

An architectural pattern where the application data is sliced into smaller, focused DbContexts rather than one monolithic Context.

  • Example: Instead of WEPV2DataContext (containing 300 tables), use ReportingContext (containing only the 5 tables needed for reports) or OrderProcessingContext.
  • Benefit: Faster startup, clear boundaries, and no risk of accidentally touching unrelated tables.
  • Context: The key strategy to moving away from the "God Class" WEPV2ModelBuilder.

God Class​

An anti-pattern where a single class does too much work, often violating the Single Responsibility Principle.

  • Examples: WEPV2ModelBuilder.cs, OrderTravelProductOMGT.cs, OrderAdvancedSearchQueryBuilder.cs (5,763 LOC).
  • Link: Wikipedia: God Object

Combinatorial Explosion​

The rapid growth in the complexity of a system as the number of independent variables (e.g., search filters) increases.

  • Context: In OMGT Search, 30 independent filter categories lead to $2^30$ possible query combinations, making SQL optimization unpredictable.

Query Pruning​

An optimization technique where parts of a query (joins or filters) are dynamically removed if they are not required by the current request parameters.

  • Goal: To reduce the SQL execution overhead and prevent Execution Plan Poisoning.

Demand-Driven Query​

A strategy where the query is constructed strictly based on active user inputs, ensuring that unused tables or relationships are never referenced in the generated SQL.

Materialized View​

A database object that contains the results of a query. For example, it may be a local copy of data located remotely, or may be a subset of the rows and/or columns of a table or join result, or may be a summary using an aggregate function.

  • Context: Used in the Feeder Pattern to store pre-calculated reporting data (e.g., WAYTDFeeder results) to avoid complex joins on the transactional database during read operations.
  • Link: Wikipedia: Materialized View

Analysis Metrics​

Hotspot Analysis​

A method of identifying high-risk code by intersecting Complexity (Lines of Code) and Frequency of Change (Churn).

Churn​

A metric representing how frequently a file is changed (committed). High churn often indicates code that is unstable or currently under heavy development.

Cyclomatic Complexity​

A quantitative measure of the number of linearily independent paths through a program's source code. We often use Lines of Code (LOC) as a proxy for this in legacy codebases.

Execution Plan Poisoning​

A situation where adding complex or redundant logic (like unnecessary Joins) to a query causes the Database Optimizer to choose a sub-optimal execution plan for subsequent, unrelated parts of the query.

Software Lifecycle (Support)​

LTS (Long Term Support)​

Version of .NET providing stable support for at least 3 years (e.g., .NET 8, .NET 10). Preferred for WepNG core services.

STS (Standard Term Support)​

Version of .NET supported for a shorter window (2 years).

Active Support Window​

The period during which a framework (like .NET or .NET Framework) receives functional updates and security patches.

Algorithmic Complexity (Big O)​

Big O Notation​

A mathematical notation that describes the limiting behavior of a function when the argument tends towards a particular value or infinity. In Computer Science, it classifies algorithms according to how their run time or space requirements grow as the input size grows.

O(1) - Constant Time​

The execution time or space used remains the same regardless of the input size.

  • Example: Accessing an array element by index.

O(N) - Linear Time​

The execution time grows directly in proportion to the input size.

  • Context: Client-Side Evaluation often leads to O(N) memory usage when fetching full tables.
  • Example: Iterating through a list.

O(N^2) - Quadratic Time​

The execution time grows proportional to the square of the input size. Performance degrades rapidly as data grows.

  • Context: String Concatenation in Loops often exhibits O(N^2) behavior due to repeated memory copying.
  • Example: Nested loops.

Modules & Systems​

BO (Back Office)​

The internal management system used by WEP staff. It is a legacy ASP.NET MVC monolithic application functions as the administrative core.

  • Status: Legacy "Big Ball of Mud".
  • Strategy: Strangler Fig migration to Headless.

OMGT (Order Management)​

The functional core managing the student exchange lifecycle (from Application to Placement and Travel).

  • Nature: Not a distinct module but a Cross-Cutting Concern woven into the monolith.
  • Criticality: Operational Critical.

WepAccess (Collaborator Portal)​

A specialized portal for external actors (Interviewers, Coordinators, Host Families) to interact with the WEP ecosystem.

  • Evolution: Candidate for the first "Headless" migration.

Security & Identity​

JWT (JSON Web Token)​

An open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object.

  • Context: Used for stateless authentication between the Legacy Monolith and Modern API.

OIDC (OpenID Connect)​

An identity layer on top of the OAuth 2.0 protocol.

  • Context: Proposed for WepNG single-sign-on (SSO) between heterogeneous modules.

Architectural Anti-Patterns​

God Controller​

A Controller class that violates the Single Responsibility Principle by handling Business Logic, Data Access, and Presentation alongside request coordination.

  • Example: CenterController.

God Service​

A Service class that concentrates too many distinct responsibilities (Authorization, Data Access, Emailing, File I/O) into a single class.

  • Example: ProfilOMGTComponentService.

Leaky Abstraction​

When a service exposes implementation details to the consumer. A common form in WepNG is returning IQueryable<T>, allowing the Controller/View to modify the SQL query.

Loop of Death​

A severe performance anti-pattern where Business Logic and Database Transactions are executed inside a loop (Transactional N+1).

Schizophrenic Architecture​

A mix of conflicting data access patterns (e.g., Direct DB access vs Service layer usage) within the same logical layer or component.

Swallowed Exceptions​

The practice of catching exceptions without logging or re-throwing them, often hiding critical failures and creating "Ghost Bugs".

Transaction Script​

Organizing business logic into procedural scripts that handle a single request, often mixing validation, calculation, and database operations.

Task.Run (Background Offloading)​

A .NET method used to queue work to run on the ThreadPool.

  • Context: Used as a tactical "quick win" to improve UI responsiveness by offloading non-critical tasks from the request thread.
  • Risk: Tasks may be lost if the AppPool recycles; potential for thread pool starvation if overused.
  • Reference: ADR-008

Persistent Task Queue​

A system (e.g., Hangfire, RabbitMQ) that ensures background tasks are persisted in a database or message broker, allowing them to survive application restarts.

  • Context: The target evolution for critical background work (like Payment Processing) currently using Task.Run.
  • Benefit: Guaranteed execution and retry logic.

Best Practices​

Command/Query Separation (CQS)​

An architectural pattern that separates operations that read data (Queries) from operations that update data (Commands).

  • Goal: To split "God Services" into focused Handlers.

CQRS (Command Query Responsibility Segregation)​

An architectural pattern that segregates operations that read data from operations that update data by using different models. This often implies separate databases (e.g., SQL for Writes, Lucene/Elastic for Reads) or Materialized Views.

  • Difference from CQS: CQS is a code-level principle (Methods). CQRS is an architectural pattern (System components).
  • Context: The Feeder Pattern is a primitive form of CQRS.

Headless Architecture​

A strategy to decouple the backend Logic (API) from the Frontend UI, enabling the use of modern frameworks (React/Vue) and multiple frontends (Mobile, Web).

Data Prefetching​

A performance pattern where related data is loaded in bulk before entering a processing loop, specifically designed to eliminate N+1 Queries during complex data processing (like Excel exporters).

Vital Core​

The essential, portable subset of the data layer (EITWEP.Model) that can be extracted to .NET Standard 2.1 for reuse across legacy and modern applications.

  • Context: The target of the Vital Core Extraction initiative.
  • Components: Wep.Core.Abstractions, Wep.Core.Data, Wep.Core.Domain.

Type Forwarding​

A .NET runtime feature that allows moving a type from one assembly to another without breaking existing callers. The CLR resolves the type at runtime via assembly metadata.

  • Context: Used in Vital Core Extraction to move entity classes from EITWEP.Model to Wep.Core.Data without modifying 10+ dependent projects.
  • Link: Microsoft Docs: Type Forwarding

Shim Assembly​

An assembly that acts as a compatibility layer, redirecting type lookups to their new locations via Type Forwarding while maintaining the original namespace and assembly identity.

  • Context: After extraction, EITWEP.Model becomes a "shim" that forwards types to Wep.Core.* assemblies.

Characterization Tests​

Tests that capture the existing behavior of legacy code without making judgments about correctness. Used before refactoring to detect unintended changes.

Ambient State​

Global state accessed implicitly by code without being passed as a parameter (e.g., HttpContext.Current, Thread.CurrentPrincipal). Creates hidden dependencies and prevents code reuse.

  • Context: The use of HttpContext.Current in EITWEP.Model is a form of Ambient State that blocks headless execution.
  • Anti-Pattern: Violates explicit dependency injection principles.