跳到主要内容

60 篇文档带有标签「quadrant:technique」

查看所有标签

Agents & Tool Calling

What an agent adds on top of a model, how to write tool contracts it cannot misread, and where the loop must stop.

ARP and VLAN

ARP and NDP neighbour resolution, proxy and gratuitous ARP, 802.1Q access and trunk ports, and where inter-VLAN routing happens.

Bandwidth, Latency and Loss

RTT, bandwidth, BDP, jitter, loss and tail latency: the arithmetic that explains why a fast link still feels slow.

BFF

GraphQL and REST backends for frontends: shaping one API per client without leaking it into the domain.

Career Development

Technology selection and the architect path: the scope, trade-offs and communication the next role expects.

Certificate Operations

ACME, private CAs, rotation and inventory: issuing and replacing certificates without an outage.

Complexity Analysis

How much work an algorithm does as its input grows, and how that estimate picks the implementation before you measure.

Computability

Turing machines and the halting problem: what no program can decide, and why.

Congestion Control

cwnd, slow start, AIMD, CUBIC, BBR, ECN and bufferbloat: how a sender guesses a network it cannot see.

Domain-Driven Design

Strategic and tactical design: bounded contexts, aggregates and the model that survives a rewrite.

Ecosystem: Scripting Workflow

Turning a notebook into a parameterized and testable script: arguments and config, logging and exit codes, atomic writes, idempotent runs, validation and scheduling.

Encapsulation and MTU

Header bytes per layer, the 1500-byte budget, MSS derivation, fragmentation and PMTUD under tunnel overhead.

End-to-End Testing

Playwright and Cypress: driving a real browser, and the flakiness that comes with it.

Ethernet and Switching

Ethernet framing, MAC learning, flooding, STP, link aggregation and duplex: how a switch moves frames inside one broadcast domain.

Failure Signatures

A symptom catalogue that maps each network failure to its layer, decisive evidence and first action.

File Systems

Ext4, ZFS and journaling: how a file survives a crash and what fsync actually promises.

Graph Algorithms

Shortest paths and minimum spanning trees: which algorithm fits which graph, and where the complexity moves.

Graph Structures

Adjacency matrices, adjacency lists, topological sort and union-find: how a graph is stored decides which algorithm is cheap.

Hardware

CPU instruction sets, the storage hierarchy and network hardware: the latency numbers every design inherits.

HTTP

How HTTP semantics stay stable while framing, multiplexing and the wire move from HTTP/1.1 to h2 and h3.

I/O Models

epoll, io_uring and zero-copy: the readiness and completion models behind a network server.

ICMP and NAT

Read ICMP error and probe traffic, diagnose PMTUD black holes, and reason about NAT mappings, conntrack timeouts and hairpin paths.

Integration Testing

Testcontainers and API mocks: testing the seam between your code and a real dependency.

IP Addressing and Subnets

Read any CIDR, derive subnet boundaries, and allocate non-overlapping IPv4 and IPv6 prefixes for sites, VLANs and containers.

Layered Architecture

MVC, clean architecture and hexagonal architecture: the dependency rule and where each boundary pays off.

Linear Structures

Arrays, linked lists, stacks, queues and hash tables: the storage trade-offs behind every collection API.

Memory Management

Virtual memory, paging and segmentation: the address space, the page table and the cost of a miss.

Microservices

Service discovery, configuration and API gateways: the operational cost of splitting a system.

OSI and TCP/IP

The seven-layer and four-layer models as a diagnostic tool: PDU names, encapsulation order and the layer that owns a failure.

Path and Latency

Splitting RTT hop by hop, separating queueing from loss, spotting asymmetry, and probing the path MTU.

Performance Testing

k6 and JMeter: load models, thresholds and the difference between a benchmark and a capacity test.

Primitives

AES, RSA, hashes, MACs and KDFs: the primitives and the parameters that keep them sound.

Processes & Threads

Scheduling and context switching: what the OS shares between execution units and what it does not.

QUIC

Streams, TLS 1.3 integration, 0-RTT, connection IDs and loss recovery: reliability moved into user space over UDP.

Realtime WebSocket and SSE

WebSocket, SSE and long polling: upgrade, frames, heartbeats, reconnect, backpressure and the proxy timeouts that break them.

Routing and BGP

Read a routing table, choose between static, OSPF and BGP, and debug prefix propagation and route selection across autonomous systems.

RPC and gRPC

When to model a call as a remote procedure, and how protobuf contracts, deadlines, trailers and streaming stay safe under retry.

Sorting & Searching

Quicksort, merge sort and binary search: the comparison model, stability, and when the input shape changes the right answer.

Supply Chain Security

SBOM, Sigstore, Snyk and Dependabot: knowing what a build contains and whether it can be trusted.

TCP

Handshake, the eleven-state machine, byte sequencing, retransmission, flow control and the TIME_WAIT tail of a close.

TLS

TLS 1.3 handshake, record layer, resumption and 0-RTT: the session a client and server agree on.

Trees & Heaps

Binary trees, red-black trees, B-trees, B+ trees and heaps: the balance and fan-out choices behind ordered data.

Troubleshooting Method

A layer-by-layer decision tree that turns refused, timeout, reset and slow into falsifiable hypotheses with the cheapest evidence.

Tunnels and VPN

Choose an encapsulation and key exchange, budget the MTU cost, and tell a handshake failure apart from a routing or policy failure.

UDP

Datagram semantics, the eight-byte header, checksum coverage and the amplification risk of a connectionless protocol.

Unit Testing

What a unit test isolates, the assertion libraries that express it, and where Vitest/Jest fits.

Web Security

OWASP Top 10, XSS, CSRF and WAF: the browser threat model and the controls that reduce it.

Wireless and Wi-Fi

802.11 framing, CSMA/CA, channels and bands, roaming, WPA2/WPA3 and interference: why wireless throughput is a shared-medium budget.