Loading…
Topic
830 posts about Architecture. Every summary links to the original.
See the idea
Amazon Bedrock is the managed reasoning tier in an agent architecture, not the whole system. This layered view shows the pipelines, governed tables, query layer, and guardrails around it.
API versioning as an architecture: requests enter through a version header, pass through a chain of reversible version changes, and reach controllers that only ever see the latest model.
BIAN gives banks a shared vocabulary and service-domain contracts that sit between business concepts and the systems implementing them. See how domains, contracts, and governed access stack into one architecture.
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Newest first
The ClickHouse .NET Driver moved from its 1.0 stable release to versions 1.1–1.3, changing how applications insert, read, and parameterize data while expanding type coverage, configurability, observability, and .NET ecosystem integrations. The largest ergonomic change is registered POCO support: RegisterPocoType() validates mappings up front, pre-compiles getters and setters, and enables InsertBinaryAsync with IEnumerable plus lazy QueryAsync() results through IAsyncEnumerable. Attributes customize column and ClickHouse type mappings, JSON serialization supports POCOs with paths and ignored properties when JsonWriteMode is Binary, and three optional extension points govern parameter type inference, wire formatting, and read conversion. The announced 1.4 roadmap targets allocation reductions, pluggable compression, and box-free POCO operations; version 1.5 is planned to add a Native/TCP client with columnar transfer and server progress information.
Enterprise data governance tools address fragmented data estates in which teams struggle to locate assets, identify ownership, protect sensitive information, and maintain consistent quality across warehouses, lakes, SaaS applications, and spreadsheets. Positioned above storage and compute, these tools read metadata, schemas, and query logs to provide a shared governance layer for cataloging, lineage, classification, policy enforcement, quality monitoring, and audit reporting. The guide distinguishes standalone catalogs, point solutions, enterprise suites, platform-native tools, and open-source options while treating AI and agent governance as an increasingly important capability for models, prompts, and autonomous agents. It recommends evaluating candidates against seven criteria, comparing total cost of ownership, and planning a phased rollout that starts with highest-risk domains; a lakehouse-native approach can reduce synchronization between separate governance systems.
Data mesh and data fabric address different constraints in distributed data architecture: mesh changes ownership and accountability, while fabric automates integration and governance. A data fabric uses active metadata, machine learning, centralized policy enforcement, and virtualized access to discover, govern, and connect data across heterogeneous environments with less data movement. A data mesh assigns domain teams responsibility for data products, quality, reliability, and lifecycle management, supported by self-serve infrastructure and federated computational governance. The article presents a lakehouse as a substrate where domains publish products while capabilities such as Unity Catalog, Delta Sharing, and Lakehouse Federation provide metadata, governance, and sharing. Its conclusion is that the approaches are complementary: organizations should identify whether organizational bottlenecks or technical fragmentation is the dominant constraint, then consider a hybrid.
Granite 4.2 is IBM’s first family of dense, decoder-only reasoning language models, offered in 3B, 8B, and 30B sizes. The models use a shared design built around Grouped Query Attention, Rotary Position Embedding, SwiGLU, RMSNorm, bfloat16 precision, and separate input/output embeddings; each has a 131,072-token sequence length. Pre-training starts from scratch on approximately 15 trillion tokens across five phases, with the final phase extending the context window to 512K tokens. Supervised fine-tuning uses about 7.2 million samples spanning agentic and non-agentic data, followed by multi-stage reinforcement learning; the 8B and 30B models also receive agentic RL in sandboxed environments for tool use, code execution, terminal control, and web search. All models support thinking, non-thinking, and low-effort thinking modes, native tool calling, and Apache 2.0 licensing.
Databricks is extending declarative ETL patterns into the Lakehouse SQL Editor so SQL practitioners can define recurring transformations without a dedicated pipelines-oriented environment. The initial operations cover append-only updates, change data capture through AUTO CDC, and targeted batch overwrites through REPLACE WHERE; flows can be scheduled, triggered by upstream updates, run on demand, or orchestrated through SQL tasks in Jobs. APPEND tracks processed source data, AUTO CDC handles keys, sequencing, deletes, and SCD Type 1 or Type 2 results, while Enzyme can incrementally process changed data for REPLACE WHERE. In Lakehouse benchmark testing, Enzyme-powered REPLACE WHERE ran 3.4x faster and 2.5x cheaper than traditional REPLACE WHERE, while users can retain procedural SQL and later move to the Lakeflow Pipelines Editor for multi-file development, dependencies, validation, and deployment.
CUDA Python 1.0, released with CUDA 13.3, presents Python as a supported way to access the full NVIDIA CUDA platform. It addresses a fragmented ecosystem in which libraries used separate binding layers, complicating shared GPU memory, streams, and resource ownership, and forcing developers toward either CUDA C++ extensions or higher-level libraries. The release combines independently versioned components, including cuda.core, cuda.compute, cuda.bindings, cuda-pathfinder, and nvmath-python, with semantic-versioning and deprecation commitments. cuda.core supplies common Python objects for devices, streams, and buffers, allowing NVIDIA and external libraries to compose on shared resources, while cuda.bindings offers 1:1 CUDA C API coverage. The stack spans runtime services, tuned CUDA libraries, communication tools, and kernel-authoring systems, although some newer kernel languages remain experimental and outside the 1.0 guarantees.
LinkedIn built a cognitive memory agent to deliver personalized experiences across its recruiter workflows and hiring assistants. Interactions between recruiters and agents often reveal recurring preferences, such as candidate criteria, role adjustments, and task habits. To preserve and manage this state throughout the entire lifecycle, the system organizes user data into a multi-tiered memory architecture. This structure comprises conversational, semantic, episodic, and procedural memory tiers that track everything from ongoing sessions to cross-session behaviors and workflow methods. LinkedIn continues to research memory abstractions, dynamic session compaction, virtual file system storage layers, and robust evaluation approaches for attribution across complex multi-source application agents.
Open table formats add metadata layers over Parquet or ORC files in object storage, enabling ACID transactions, schema evolution, time travel, and database-like consistency for data lakes. Apache Iceberg uses manifests and manifest lists in a metadata tree, supports partition evolution without rewriting existing files, and creates immutable snapshots for auditing, rollback, and reproducible queries. Delta records atomic writes in an ordered transaction log with checkpoints and is closely associated with Spark, while Hudi uses record-level indexes for frequent updates, change-data-capture, and near-real-time ingestion. All three share core capabilities but differ in partition evolution, update and delete strategies, and multi-engine support; Parquet and ORC remain file formats rather than table formats. The overview recommends scheduled compaction, metadata maintenance, health monitoring, and a production-volume proof of concept when selecting a format.
The updated Okta Angular SDK introduces fully standalone architecture, eliminating NgModules and wrapper functions in favor of standalone providers and functional guards. In an Angular v22 sample project, authentication is configured with the provideOktaAuth function without requiring a custom backend. Route security utilizes functional guards, while user and group data fetch flows are handled using rxResource alongside signal inputs. To support dynamic environments without requiring rebuilds or redeployments, the setup implements runtime configuration loading via provideAppInitializer and OktaAuthConfigService. Security is further bolstered by binding access tokens to browser key pairs using Demonstrating Proof of Possession alongside OAuth 2.1 and OpenID Connect protocols.
Red Hat OpenShift supports compute scaling using Cluster Autoscaler integrated with the OpenShift machine API. The mechanism relies on paired ClusterAutoscaler and MachineAutoscaler custom resources to manage cluster-wide limits and per-MachineSet replica boundaries. Scaling decisions evaluate pending pods against node allocatable capacity and hypothetical node capacity annotations while respecting expander strategies like Random, LeastWaste, or Priority. Cluster Autoscaler checks for unnecessary nodes every 10 seconds, scaling down when utilization falls below configured thresholds and workloads can safely migrate. To mitigate provisioning delays, clusters can adopt overprovisioning via low-priority pause containers or use APIs like ProvisioningRequest and CapacityBuffer for predictive scaling.
AI applications are presented as pipelines that chain image, text, audio, and dataset operations, with intermediate values otherwise investigated through print-debugging. gr.Workflow turns these pipelines into graphs of typed nodes, served as a drag-and-drop canvas where each node runs independently and its result remains visible. Operators can be Python functions, Hugging Face Inference Providers models, Gradio Spaces, Hub dataset rows, or GPU-backed functions using ZeroGPU, while fan-out connections run multiple analyses or generations in parallel. The same workflow also exposes labeled outputs as REST endpoints callable through the Gradio client or curl, and can be deployed to Hugging Face Spaces with one command.
Existing multimodal models struggle with structural fragmentation, often sacrificing visual fidelity via discrete tokenization or breaking structural symmetry by pairing causal text generation with diffusion-based denoising. STARFlow2 addresses these limitations by leveraging autoregressive normalizing flows, which share the causal mask, key-value cache mechanism, and left-to-right structure of large language models. Built upon the Pretzel architecture, the system vertically interleaves a frozen pretrained vision-language model stream with a TARFlow stream through residual skip connections under a single causal mask. A deep-shallow flow design combined with a unified FAE latent space allows both text and continuous visual outputs to enter the key-value cache directly without re-encoding. Benchmark experiments validate strong performance across multimodal understanding and continuous image generation tasks.
Salesforce addressed an operational challenge where sellers faced roughly 12,000 dashboards and over 20 applications outputting machine learning predictions without clear next steps. The engineering team reframed machine learning outputs as raw signals rather than standalone answers. To bridge the gap between assessment and action, they built a Next Best Action layer that combines model signals, business logic, and contextual institutional knowledge into actionable recommendations. They integrated this layer with an AI agent using Model Context Protocol (MCP) tool contracts, enabling dynamic discovery and explicit handling of missing data. Finally, rather than introducing a separate dashboard destination, the agent serves on-demand recommendations directly inside Slack where sellers already collaborate.
Cloudflare migrated its official blog to EmDash, an Astro-focused content management system, acting as internal Customer Zero to evaluate scaling and usability. To prepare for traffic spikes reaching thousands of requests per second, engineers used k6 to execute ramp, breakpoint, and burst load tests. The resulting production architecture runs EmDash on Cloudflare Workers, pairing it with Workers Cache, an object cache backed by Workers KV, and Hyperdrive connected to PlanetScale. This layered caching design serves 99.5 percent of static files and 70 percent of requests from cache, flattening p95 latency under real-world loads reaching 850 requests per second. The migration also introduced a frontend redesign using the Kumo design system and added Model Context Protocol servers for automated agent workflows.
MTIA 300 is Meta’s first in-house training and inference accelerator optimized for ranking and recommendation models. These workloads require frequent AllReduce, AllToAll, and AllGather operations because embedding tables can contain over 99% of model parameters, making communication a bottleneck that competes with computation on GPUs. Its package-integrated network uses two chiplets with twelve custom 800 Gbps RDMA NICs, while 16 message engines and near-memory compute handle collectives independently of the 12×6 processing-element grid. Co-designed HCCL compiles collectives into dependency-aware subgraphs for autonomous execution, with topology-aware algorithms spanning scale-up and scale-out links. In production, HCCL reaches up to 940 GB/s within a rack, and a 150-billion-parameter model across 40 accelerators completed communication 3.9 times faster than an equivalent GPU cluster; concurrent GEMMs degraded less than 0.5%.
Selecting between relational and non-relational databases requires matching the data store to requirements for structure, consistency, scale, and query complexity. Relational systems organize data in predefined tables, enforce schemas and keys, and provide ACID transactions, making them suited to structured, transactional workloads and complex joins. Non-relational systems support documents, key-value pairs, graphs, or wide-column structures, often using flexible schemas and schema-on-read while scaling horizontally and accepting eventual consistency for throughput and availability. The trade-offs include vertical versus horizontal scaling, SQL versus database-specific query languages, and database-enforced versus application-level integrity. The guidance recommends documenting workload needs, prototyping with realistic volumes and failure scenarios, and considering polyglot persistence when different workloads require specialized systems.
Transactional and analytical databases serve different workloads: OLTP handles high-volume, real-time reads and writes with ACID guarantees, while OLAP supports complex queries over large historical datasets for reporting and business intelligence. The comparison focuses on trade-offs involving latency, concurrency, data freshness, schema design, transaction size, and storage format. Row-oriented storage and normalized schemas support precise operational updates, whereas column-oriented storage and denormalized designs improve compression, scans, and aggregations across millions of rows. The source describes transactional systems as foundational for applications such as banking, e-commerce, healthcare, and reservations, while analytical systems support dashboards, forecasting, and ad-hoc analysis. Its recommended architecture is to run both systems independently and connect them with Change Data Capture, balancing operational reliability with analytical throughput.
A global payment processor migrating 382 AWS accounts between AWS Organizations encountered control-plane failures when AWS Resource Access Manager automatically severed organization-bound resource shares. Although data planes continued operating for shared resources such as AWS Transit Gateways, infrastructure automation lost the ability to modify dependencies like AWS Glue Data Catalog databases. The engineering team resolved this by implementing temporary retained bridge shares, establishing external principal associations that survived cross-organization account transfers. Following each account move, automated tooling restored durable original shares, validated Lake Formation permissions, and deleted the bridge copies to prevent configuration drift. This bridge-share workflow enabled the migration of 378 accounts before a Transitional Service Agreement deadline without customer downtime.
Generative AI training across hundreds of thousands of GPUs makes the scale-out network a first-order performance bottleneck, because synchronized collectives expose weaknesses in conventional Ethernet. Static ECMP, packet loss controls such as PFC, and slowly tuned congestion control can create stragglers, head-of-line blocking, latency spikes, and multi-tenant interference. Spectrum-X Ethernet addresses these conditions with hardware-accelerated adaptive per-packet routing, targeted ECN- and RTT-based congestion control, and a SuperNIC Plane Load Balancer that distributes traffic across independent network planes. Spectrum-X Multiplane uses shallow two-tier fat trees and host-edge optical devices to provide path diversity while scaling a two-tier design to over 128,000 endpoints. In the cited tests, Spectrum-X sustained 98% of theoretical line rate across GPU pairs, held P99 tail latency to 8–9 microseconds under 75% load, recovered from a link flap in 2.68 milliseconds, and limited bandwidth loss under 10% fabric failure to 11%.
Agentic AI inference has shifted from single-turn requests to long, stateful workflows that reason, invoke tools, coordinate subagents, and reuse growing context, increasing token and power demands. The post presents SemiAnalysis AgentX, an InferenceX benchmark that replays prerecorded Claude Code sessions turn by turn, preserving context, input/output lengths, reasoning time, tool-call latency, and KV-cache pressure while varying concurrency. It evaluates tokens per megawatt alongside E2E normalized interactivity, standard interactivity, E2E latency, and TTFT; NVIDIA-measured Vera Rubin NVL72 results, pending SemiAnalysis review, show up to 30x higher throughput per megawatt than GB300 NVL72 at 160 tokens per second per user. GB300 also delivers up to 15x H200 throughput per megawatt, up to 10x lower cost per million tokens, and roughly 80x higher throughput on Kimi K3 2.8T, supported by MoE runtimes, communication overlap, Dynamo, and NVLink.
The best engineering reads, once a week.
