architecture - Concepts

Explore concepts tagged with "architecture"

Total concepts: 64

Concepts

Context Layering - Architectural pattern of organizing AI context into hierarchical layers with defined scope, precedence, and inheritance from global to task-specific.
SOLID Principles - Five fundamental design principles for creating maintainable, scalable, and flexible object-oriented software systems.
Local-First - Software design where data lives primarily on your devices, with cloud as optional sync.
Attention Mechanism - An AI technique that allows models to focus on relevant parts of input when producing output.
Sparse Models - Neural network architectures where only a fraction of parameters are activated for any given input, enabling larger model capacity with lower computational cost.
Context Isolation - Keeping contexts separated to prevent cross-contamination between different tasks or agents.
Specification-Driven Design - An approach to software development where a formal specification document drives the design, implementation, and validation of the system.
Strangler Fig Pattern - A migration strategy that gradually replaces a legacy system by building new functionality alongside it until the old system can be decommissioned.
Monolithic Architecture - A software architecture pattern where an entire application is built as a single, unified unit.
Encapsulation - The principle of bundling data and behavior together while hiding internal implementation details behind a well-defined public interface.
Distributed Systems - Computing systems composed of multiple independent components located on different networked computers that coordinate to achieve a common goal.
Separation of Concerns - A design principle for dividing a system into distinct sections, each addressing a separate concern or responsibility.
Client-Server Architecture - A distributed computing model where client applications request services and resources from centralized servers over a network.
Microservices Architecture - A distributed architecture style that structures an application as a collection of small, autonomous services organized around business capabilities.
AI Agent Portability - The ability to run AI agents across different platforms, models, and environments without significant rearchitecting or loss of functionality.
Clean Architecture - A software architecture pattern that emphasizes separation of concerns through concentric layers with dependencies pointing inward.
Transformer - The neural network architecture underlying modern AI language models.
Zero Trust - Security model that requires strict verification for every user and device, regardless of network location
AI Heartbeat Pattern - Design pattern where AI agents periodically wake up at configured intervals to check for changes, tasks, or events rather than waiting for explicit invocation.
Prompt Lazy Loading - An AI design pattern that defers loading detailed prompt instructions until they are actually needed.
GraphQL - A query language for APIs that lets clients request exactly the data they need.
Coupling - The degree of interdependence between software modules, with low coupling meaning modules can be understood, changed, and tested independently.
Decentralization - Distributing control, data, or operations across multiple independent nodes rather than centralizing.
Context Mapping - A strategic DDD technique for visualizing and managing the relationships and integration patterns between bounded contexts.
Edge AI - Running artificial intelligence models directly on local devices (phones, IoT sensors, cars) rather than in the cloud, enabling faster responses and greater privacy.
Design Patterns - Reusable solutions to commonly occurring problems in software design, providing templates for solving design challenges.
API - A set of rules and protocols that allows different software applications to communicate with each other.
Unix Philosophy - A set of design principles favoring small, focused programs that do one thing well and can be composed together through simple interfaces.
Saga Pattern - A pattern for managing distributed transactions across multiple services by coordinating a sequence of local transactions with compensating actions for failures.
Project Context Management - Managing AI context specific to a project including codebase knowledge, conventions, and architectural decisions.
REST - An architectural style for web services that uses standard HTTP methods and stateless communication.
Anti-Corruption Layer - A translation layer that isolates a bounded context from external or legacy systems, preventing their models from contaminating the internal domain model.
Evolutionary Architecture - An architectural approach that supports guided, incremental change across multiple dimensions by building systems designed to adapt as requirements and environments evolve.
Modularity - The design principle of organizing systems into self-contained, interchangeable components with well-defined interfaces, enabling independent development and evolution.
Architectural Fitness Functions - Automated tests and metrics that objectively assess how well a software architecture meets its intended quality goals, enabling continuous architectural governance.
Privacy by Design - Building privacy protections into systems from the start rather than adding them later.
Receptionist AI Design Pattern - An AI architecture pattern using a lightweight coordinator to route requests to specialized AI agents.
Schema - A formal structure that defines the organization, constraints, and relationships of data within a system.
Aggregate - A cluster of domain objects treated as a single unit for data changes, with a root entity that controls all access and enforces invariants.
Conway's Law - Organizations design systems that mirror their own communication structures.
Mixture of Experts - A neural network architecture that uses a gating network to route inputs to specialized sub-networks called experts, enabling efficient scaling by activating only a subset of parameters for each input.
Context Inheritance - How child contexts automatically receive and can override parent context settings.
CAP Theorem - A theorem stating that distributed data stores can only guarantee two of three properties: Consistency, Availability, and Partition tolerance.
Software Entropy - The tendency of software systems to become increasingly disordered and complex over time without active maintenance.
Conceptual Integrity - The principle that a system's design should reflect a unified, coherent set of ideas as if conceived by a single mind, which Brooks considered the most important consideration in system design.
Opinionated Software - Software that prescribes a particular way of doing things, making design decisions for users rather than offering maximum flexibility.
Technology Radar - A visualization technique for tracking and communicating technology adoption decisions, categorizing technologies by their maturity and recommended adoption status.
Domain Event - A record of something significant that happened in the business domain, used to communicate state changes and trigger side effects across system boundaries.
Domain-Driven Design - An approach to software development that centers the design on the core business domain and its logic.
CQRS - A pattern that separates read and write operations into distinct models, allowing each to be optimized, scaled, and evolved independently.
Cohesion - The degree to which elements within a module belong together, with high cohesion meaning a module is focused on a single, well-defined purpose.
Event Sourcing - A pattern that persists the state of an entity as a sequence of immutable events rather than storing only the current state.
Offline-First - A software design approach where applications are built to work fully without an internet connection, treating connectivity as an enhancement rather than a requirement.
Service-Oriented Architecture - An architectural style that organizes software as a collection of interoperable services that communicate through standardized interfaces.
Single Responsibility Principle - The software design principle stating that a module, class, or function should have one and only one reason to change, keeping it focused on a single concern.
Single File Component - A component architecture where template, logic, and styles are co-located in a single file.
Gating Network - A neural network component that learns to route inputs to the most appropriate expert sub-networks in mixture of experts architectures.
Eventual Consistency - A consistency model in distributed systems where, given enough time without new updates, all replicas of the data will converge to the same value, trading immediate consistency for higher availability.
Architecture Decision Records - A systematic method for documenting architectural and technical decisions, their context, and rationale to preserve knowledge for future maintainers.
Modulith - A modular monolith architecture that combines the simplicity of monoliths with the organizational benefits of microservices.
Software Architecture - The high-level structure of a software system, defining its components, their relationships, and the principles governing its design and evolution.
Bounded Context - A central pattern in Domain-Driven Design that defines explicit boundaries within which a domain model is defined and applicable.
Defense in Depth - A layered security approach using multiple protective measures so failure of one doesn't compromise the system
Agent Orchestration - The coordination and management of multiple AI agents, including their workflows, communication, task delegation, and error handling to achieve complex goals.

← Back to all concepts