跳到主要内容

155 篇文档带有标签「ring:adopt」

查看所有标签

Accessibility and SEO

Accessible names, roles and keyboard paths; contrast and motion preferences; and the crawlability signals that make a document indexable and understandable.

AOP

Go 没有切面语言,横切逻辑只能写成显式包装:HTTP 中间件、高阶函数装饰器、go:generate 代码生成、运行时钩子或服务网格;本页说明链的注册顺序、短路语义与缺失请求 ID、context 丢失、重复注册、生成物漂移四类故障。

AOP

Java 的切面编程:Spring AOP 的运行期代理与 AspectJ 的字节码织入,切点与通知的语义,以及自调用、顺序与代理边界导致的失效。

AOP

JavaScript 没有 AspectJ 式的编译期织入:装饰器、Proxy、中间件、猴子补丁与运行时插桩各自负责一段横切逻辑,选型的核心是织入时机、执行顺序与不能破坏的不变量。

AOP

Python 的切面实践:装饰器在定义时如何把函数替换成包装,上下文管理器如何保证配对释放,元类与类装饰器如何介入类创建,以及 functools.wraps、叠加顺序与猴子补丁带来的可观测性与一致性代价。

AOP

Rust 没有运行期织入与注解代理,横切逻辑只能用泛型包装器、dyn 包装、宏和 tower 中间件显式组合,代价是单态化膨胀与必须自己维护调用顺序。

Architecture

Spring Boot auto-configuration, the bean lifecycle, dependency injection and externalized configuration.

Architecture

How a Vue application is assembled: component communication, router guards, Pinia stores, composables, and the server rendering pipeline that Nuxt adds on top.

ARP and VLAN

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

Async

Go 没有 async/await,异步由 goroutine、channel 与 context 组合而成;本页说明 errgroup、worker pool、取消与背压的机制,区分异步与并行,并给出 goroutine 泄漏、无缓冲死锁、取消不传播、循环变量捕获四类故障的排查路径。

Async

Java 的异步模型:CompletableFuture 的组合与陷阱、虚拟线程的调度与成本、响应式流的背压,以及执行器、超时与取消的边界。

Async

The event loop and its task queues, Promise states and combinators, async and await sequencing, timers and cancellation, and the worker and backpressure boundaries.

Async

Python 的异步模型:asyncio 事件循环如何调度协程与任务,TaskGroup 如何实现结构化并发,取消、超时与背压的语义边界,to_thread 如何隔离阻塞调用,以及 GIL 之下异步能解决与不能解决什么。

Async

async fn 被编译成惰性的 Future 状态机,执行器轮询、反应器唤醒、Pin 固定地址,取消由 drop 完成;理解这套分工才不会把阻塞调用塞进运行时。

Bandwidth, Latency and Loss

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

Batch Processing

Spark: the shuffle, the DAG and the cost of a wide transformation.

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.

Cascade and Specificity

How a declaration wins: origin and importance, cascade layers, the specificity triple, inheritance keywords, and custom properties that pass through the whole tree.

CDN

Edge delivery as a tiered cache: anycast ingress, origin shield, cache key, purge propagation, edge TLS and multi-CDN steering, plus the failures that look like origin bugs.

Certificate Operations

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

CI/CD

GitHub Actions and Jenkins: pipeline stages, caching and the failure modes of a shared runner.

Code Quality

ESLint, Prettier and SonarQube: the rules that catch defects versus the rules that only argue about style.

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.

Concept

Go 的设计取舍:少关键字、组合代替继承、显式错误、goroutine 与 GC,以及“简单但可预测”这个目标如何决定语言、运行时和工具链的边界。

Concept

Java 用静态名义类型、JVM 字节码、类加载、JIT 与 GC 组成一套运行时契约,换来跨平台与生态,代价是启动预热和内存占用。

Concept

JavaScript 的心智模型由四件事组成:一个调用栈上的单线程执行、一套运行期才检查的动态类型、一条原型委托链,以及一个由宿主驱动的事件循环;JIT 分层与 ESM/CJS 并存是这套模型的补丁,TypeScript 则在编译期把类型补回来。

Concept

Python 的工程心智模型:动态强类型与鸭子类型如何决定接口,CPython 如何把源码编译成字节码、用引用计数加分代 GC 管理对象,GIL 如何限定并行,以及打包分发为何成为主要成本。

Concept

Rust 用所有权、借用检查与 trait 抽象取代垃圾回收,在编译期证明内存与线程安全,以更陡的学习曲线和更长的编译时间换取确定性的释放时机与接近 C 的运行性能。

Concurrency

GMP 调度与 M:N 复用、goroutine 成本与生命周期、channel 的阻塞与关闭语义、select 与超时、context 取消传播、Mutex/WaitGroup/atomic、happens-before 与数据竞争、worker pool、扇出扇入与泄漏排查、pprof 剖析。

Concurrency

Platform threads, virtual threads, coroutines and effect systems: how each JVM language expresses concurrency.

Concurrency

同一个线程上交错推进任务与真正并行是两件不同的事:事件循环的阶段与队列决定执行顺序,Worker、子进程、共享内存与背压决定能否把 CPU 工作搬出主线程。

Concurrency

The GIL, threads, processes and asyncio: which execution model fits which load, how cancellation propagates, and where blocking calls and missing backpressure break a service.

Congestion Control

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

Data Pipelines

dbt and Airflow: transforming data in SQL and scheduling the DAG around it.

DNS

The delegation chain, resolver roles, record types and TTL rules that decide why a name resolves or silently does not.

DNSSEC and DNS Operations

The DS/DNSKEY/RRSIG chain, why validation fails, and the TTL, registrar and migration sequencing that keeps a zone resolvable.

Docker

An image is a stack of layers, a container is one process; how to build, run and review one without leaking the toolchain into production.

Document Structure and Semantics

The document tree, the seven content models, the elements that carry meaning, global attributes and the metadata that decides encoding, viewport and language.

DOM and Events

The document object model as a programming surface: node types, query and mutation APIs, the capture and bubble flow, delegation, observers and shadow roots.

Domain-Driven Design

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

Ecosystem: Dataframes

pandas and Polars: columnar memory, vectorized expressions, lazy plans and streaming, join and null semantics, and the point where a single machine stops being enough.

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.

Ecosystem: Standard Library

Node core modules as a surface: fs in three styles, Buffer, streams and backpressure, HTTP and net, worker threads, child processes, and the errno conventions that carry through.

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.

Error

error 接口、哨兵错误与自定义类型、%w 包装链、errors.Is/As/Join、panic 与 recover 的同 goroutine 边界、包设计与 internal/ 的导入约束、导入环、服务错误分类与对外错误码,以及导出标识符和弃用注释的兼容性规则、init 失败只能 panic 的处理。

Error

Java 的失败处理:受检与非受检异常的契约,try-with-resources 与抑制异常,异常链的因果关系,以及领域错误在边界上的转换。

Error

The Error family, throw and try semantics with cause chains, ESM static linking and live bindings, CJS interop, and the circular-dependency and dual-package failures that follow.

Error

Python 的错误处理:异常对象如何沿栈展开并匹配 handler,try/except/else/finally 与 with 的执行顺序,raise from 如何建立根因链,3.11 的异常组如何聚合并发失败,以及捕获、翻译与清理的边界。

Error

Rust 把失败编码进类型:Result 承载可恢复错误、Option 表示缺失、panic 留给不变量破坏,? 与 From 让错误沿调用链携带上下文向上传播。

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.

Feature: Interop

Mixing Java, Kotlin and Scala in one build: the bytecode contract, the guarantees that vanish across the boundary, and how to choose.

File Systems

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

Forms and Inputs

Native data collection: the twenty-two input types, constraint validation, labels and grouping, the submit encoding path, and FormData at the boundary.

Functions

函数作为一等值、多返回值与命名结果、变参打包、闭包捕获与 Go 1.22 的每轮循环变量、defer 的求值顺序与 panic 展开、值接收者复制与指针接收者共享、方法集与接口满足、结构体嵌入与方法提升、方法值绑定接收者的时机、init 的初始化顺序与常见风险、调用求值顺序与 nil 函数调用。

Functions

Java 把行为写成方法、lambda、方法引用与函数接口,本页拆解重载解析、变长参数、捕获规则与 invokedynamic 在运行时的真实代价。

Functions

Functions as first-class values: declaration forms, parameters, lexical scope, hoisting and the temporal dead zone, closures, and the four rules that fix this at call time.

Functions

Argument binding, closures and decorators, generators, context managers, the exception contract, and the gradual type system that documents all of them.

Functions

Rust 把函数与闭包当作可传递的值:fn 项、泛型约束、捕获方式与 Fn 系列 trait 共同决定调用点是内联、单态化还是间接调用。

Global Traffic Management

Cross-region steering with GeoDNS, latency-based routing, GSLB and anycast, where failover is bounded by DNS TTL and active-active capacity assumptions break first.

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.

Health Checks and Draining

Probe design and the exit path: liveness versus readiness, active and passive detection thresholds, draining in-flight requests, and failures that remove every backend at once.

HTTP

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

HTTP Caching

Freshness, validators and the shared-versus-private split: how Cache-Control directives, Vary and conditional requests decide reuse, and where invalidation fails.

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.

Kubernetes

The control plane and the pod lifecycle: how a declared state becomes running containers.

Layered Architecture

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

Layout

Box model and box sizing, formatting contexts, positioning and stacking, then flex for one axis and grid for two, with the auto-sizing rules that explain the odd results.

Lifecycle

Elements, components and fibers: the render and commit phases, how keys decide identity, where effects run, and what Strict Mode, Suspense and server components change about all of it.

Linear Structures

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

Load Balancing

Connection and request distribution: what L4 and L7 can see, how NAT, DSR and PROXY protocol move traffic, where TLS terminates, and why affinity blocks scale-out.

Memory Management

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

Messaging & Events

Kafka, RabbitMQ and Pulsar: the log, the queue and the delivery guarantees between them.

Microservices

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

Middleware

The Spring Security filter chain, Actuator and Micrometer, startup, probes and graceful shutdown.

Navigation and Network

How an address becomes a document: navigation steps, the History API, back-forward cache, Fetch options, CORS preflight, and the HTTP cache headers that decide reuse.

Network Metrics

Which network signals to instrument, how to aggregate them honestly, and how to turn RTT, retransmits and handshakes into SLOs that page early.

NoSQL Databases

Redis, MongoDB and Neo4j: the data models that justify giving up a relational schema.

OOP

接口值为什么不是 nil、隐式满足与方法集规则、typed nil 陷阱、类型断言与类型 switch、消费方小接口,以及泛型的类型参数、comparable 与 ~ 近似项、联合约束、实例化与类型推断、接口与泛型的选型边界和装箱成本、约束接口不能作变量类型、类型参数的编译期检查。

OOP

Java 的面向对象:类、接口、记录、枚举与密封层级的取舍,继承与组合的边界,以及分派、equals/hashCode 与脆弱基类的约束。

OOP

Objects as property bags: descriptors, getters, the prototype chain, class syntax, private fields, Symbol keys, and the Proxy and Reflect pair that intercepts every operation.

OOP

Python 的面向对象:类如何由类体执行与元类共同创建,属性查找为何先描述符后实例字典,C3 线性化如何决定 MRO 与 super 的走向,以及 dataclass、Protocol、ABC 与组合在动态分派下的分工与边界。

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.

Packet Capture

Choosing a capture point, writing narrow filters, bounding file size, and reading a handshake or RST without leaking credentials.

Path and Latency

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

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.

Relational Databases

PostgreSQL and MySQL: the relational model, the planner and the operational differences between them.

Rendering Pipeline

From bytes to pixels: parsing, the render tree, layout, paint and compositing, which properties trigger which stage, and the long task and layout thrash that break the frame budget.

Responsive and Motion

Viewport units, media and container queries, fluid type with clamp, responsive images, and the transition and animation rules that keep motion cheap and optional.

Routing

The Spring MVC request path, validation and error mapping, then transactions, JPA and the connection pool behind 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.

Runtime

Go 运行时如何把 goroutine 调度到线程、如何分配内存、如何并发标记回收:GMP、work stealing、mcache/mcentral/mheap、三色标记、写屏障、pacer 与 GOGC/GOMEMLIMIT 的取舍。

Runtime

Node.js on V8 and libuv: the event loop, the thread pool and the boundary between JavaScript and the OS.

Runtime: Class Loading

The class file, the loading and linking phases, class loader hierarchy, reflection and the leaks a class loader can hold.

Runtime: JIT and Threads

Tiered compilation, inlining and deoptimization, safepoints, the Java Memory Model and how virtual threads change the cost of blocking.

Runtime: Memory and GC

Runtime data areas, allocation, the garbage collectors compared, pause budgets and the OOM types that follow.

Sorting & Searching

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

State and Data

Where each kind of state belongs: local, lifted, context, external store, URL and server cache; how subscriptions stay tear-free; and how races, invalidation and optimistic updates decide correctness.

State and Data

Proxy-based dependency tracking: ref and reactive, computed caching, watch flush timing, batched updates in a microtask, and what the template compiler does before render.

Storage

Cookies, local and session storage, IndexedDB and the cache API: scope, lifetime, quota, eviction, and the one decision that matters most, where a session token lives.

Syntax

Go 的语法面:25 个关键字、预声明标识符、字面量与运算符、语句形式,以及自动分号插入和版本边界带来的陷阱。

Syntax

Java 的语法面:50 个关键字、字面量与语句骨架,以及 record、sealed、模式匹配和文本块在 8/11/17/21 上的版本边界。

Syntax

The eight runtime types, the conversion and equality algorithms that connect them, numeric and string precision, and the expression and statement forms that produce them.

Syntax

Python 的语法面:35 个关键字如何划出语句边界,缩进为何是语法而不是风格,推导式、装饰器、海象运算符与 match 各自的求值规则,以及 3.8 / 3.10 / 3.11 / 3.12 的版本门槛。

Syntax

Rust 的语法把声明、模式解构与类型约束写在同一套表达式规则里,用 match 的穷尽性、? 的短路传播和生命周期标注把控制流与借用范围显式化。

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.

Toolchain

Vite, Webpack, pnpm and Vitest: how source becomes a bundle, a dependency tree and a test result.

Toolchain: Declarations and Config

Where types come from: source, declaration files and inference; how the compiler resolves modules; how tsconfig and project references organise a build; and the two decorator systems.

Toolchain: Modules and Packaging

The import system, the src layout, pyproject build backends, wheels and sdists, and the environment and lock tools that make a resolution reproducible.

Toolchain: Testing

JUnit 5 architecture, the extension model, test doubles, Testcontainers and the surefire and failsafe split.

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.

Type

Go 的值模型:基本类型与零值、显式转换和类型身份、常量与 iota 的求值、string/byte/rune 的 UTF-8 边界、slice 头的 len/cap、append 扩容与别名、map 的引用语义、struct 对齐填充、指针复制语义、可比较规则,以及逃逸分析如何决定栈或堆。

Type

Nominal typing, generics and erasure, null safety and algebraic data types across Java, Kotlin and Scala.

Type

Arrays, typed arrays, Map, Set and the weak variants, the iterator and generator protocols that unify them, and the traversal forms whose differences decide correctness.

Type

How CPython compiles and executes a module, how names bind to objects, how reference counting and the cyclic GC decide a lifetime, and how protocols decide identity, equality and attribute access.

Types: Generics and Operators

Type parameters and constraints, keyof and indexed access, conditional and mapped types with infer and key remapping, template literal types, and the twenty-two built-in utility types.

Types: Narrowing

Structural typing, the assignability rules behind it, the three escape types, and the eight narrowing forms that turn a runtime check into a static guarantee.

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.

Version Control

The Git object model, branching and the GitHub/GitLab workflows built on top of it.

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.