Accessibility and SEO
Accessible names, roles and keyboard paths; contrast and motion preferences; and the crawlability signals that make a document indexable and understandable.
Accessible names, roles and keyboard paths; contrast and motion preferences; and the crawlability signals that make a document indexable and understandable.
Go 没有切面语言,横切逻辑只能写成显式包装:HTTP 中间件、高阶函数装饰器、go:generate 代码生成、运行时钩子或服务网格;本页说明链的注册顺序、短路语义与缺失请求 ID、context 丢失、重复注册、生成物漂移四类故障。
Java 的切面编程:Spring AOP 的运行期代理与 AspectJ 的字节码织入,切点与通知的语义,以及自调用、顺序与代理边界导致的失效。
JavaScript 没有 AspectJ 式的编译期织入:装饰器、Proxy、中间件、猴子补丁与运行时插桩各自负责一段横切逻辑,选型的核心是织入时机、执行顺序与不能破坏的不变量。
Python 的切面实践:装饰器在定义时如何把函数替换成包装,上下文管理器如何保证配对释放,元类与类装饰器如何介入类创建,以及 functools.wraps、叠加顺序与猴子补丁带来的可观测性与一致性代价。
Rust 没有运行期织入与注解代理,横切逻辑只能用泛型包装器、dyn 包装、宏和 tower 中间件显式组合,代价是单态化膨胀与必须自己维护调用顺序。
Spring Boot auto-configuration, the bean lifecycle, dependency injection and externalized configuration.
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 NDP neighbour resolution, proxy and gratuitous ARP, 802.1Q access and trunk ports, and where inter-VLAN routing happens.
Go 没有 async/await,异步由 goroutine、channel 与 context 组合而成;本页说明 errgroup、worker pool、取消与背压的机制,区分异步与并行,并给出 goroutine 泄漏、无缓冲死锁、取消不传播、循环变量捕获四类故障的排查路径。
Java 的异步模型:CompletableFuture 的组合与陷阱、虚拟线程的调度与成本、响应式流的背压,以及执行器、超时与取消的边界。
The event loop and its task queues, Promise states and combinators, async and await sequencing, timers and cancellation, and the worker and backpressure boundaries.
Python 的异步模型:asyncio 事件循环如何调度协程与任务,TaskGroup 如何实现结构化并发,取消、超时与背压的语义边界,to_thread 如何隔离阻塞调用,以及 GIL 之下异步能解决与不能解决什么。
async fn 被编译成惰性的 Future 状态机,执行器轮询、反应器唤醒、Pin 固定地址,取消由 drop 完成;理解这套分工才不会把阻塞调用塞进运行时。
OAuth 2.1, OIDC, RBAC and ABAC: proving identity and deciding what it may do.
Regular and context-free languages: the machines that recognise them and the limits of each.
RTT, bandwidth, BDP, jitter, loss and tail latency: the arithmetic that explains why a fast link still feels slow.
Spark: the shuffle, the DAG and the cost of a wide transformation.
GraphQL and REST backends for frontends: shaping one API per client without leaking it into the domain.
Technology selection and the architect path: the scope, trade-offs and communication the next role expects.
How a declaration wins: origin and importance, cascade layers, the specificity triple, inheritance keywords, and custom properties that pass through the whole tree.
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.
X.509 fields, SAN matching, chain building and trust stores: proving that a public key belongs to a name.
ACME, private CAs, rotation and inventory: issuing and replacing certificates without an outage.
GitHub Actions and Jenkins: pipeline stages, caching and the failure modes of a shared runner.
ESLint, Prettier and SonarQube: the rules that catch defects versus the rules that only argue about style.
How much work an algorithm does as its input grows, and how that estimate picks the implementation before you measure.
Turing machines and the halting problem: what no program can decide, and why.
P, NP and NP-hard: what a problem class says about the algorithm you can expect.
Go 的设计取舍:少关键字、组合代替继承、显式错误、goroutine 与 GC,以及“简单但可预测”这个目标如何决定语言、运行时和工具链的边界。
Java 用静态名义类型、JVM 字节码、类加载、JIT 与 GC 组成一套运行时契约,换来跨平台与生态,代价是启动预热和内存占用。
JavaScript 的心智模型由四件事组成:一个调用栈上的单线程执行、一套运行期才检查的动态类型、一条原型委托链,以及一个由宿主驱动的事件循环;JIT 分层与 ESM/CJS 并存是这套模型的补丁,TypeScript 则在编译期把类型补回来。
Python 的工程心智模型:动态强类型与鸭子类型如何决定接口,CPython 如何把源码编译成字节码、用引用计数加分代 GC 管理对象,GIL 如何限定并行,以及打包分发为何成为主要成本。
Rust 用所有权、借用检查与 trait 抽象取代垃圾回收,在编译期证明内存与线程安全,以更陡的学习曲线和更长的编译时间换取确定性的释放时机与接近 C 的运行性能。
GMP 调度与 M:N 复用、goroutine 成本与生命周期、channel 的阻塞与关闭语义、select 与超时、context 取消传播、Mutex/WaitGroup/atomic、happens-before 与数据竞争、worker pool、扇出扇入与泄漏排查、pprof 剖析。
Platform threads, virtual threads, coroutines and effect systems: how each JVM language expresses concurrency.
同一个线程上交错推进任务与真正并行是两件不同的事:事件循环的阶段与队列决定执行顺序,Worker、子进程、共享内存与背压决定能否把 CPU 工作搬出主线程。
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.
cwnd, slow start, AIMD, CUBIC, BBR, ECN and bufferbloat: how a sender guesses a network it cannot see.
Raft and Paxos: how replicas agree on one order, and the failures each protocol tolerates.
dbt and Airflow: transforming data in SQL and scheduling the DAG around it.
The delegation chain, resolver roles, record types and TTL rules that decide why a name resolves or silently does not.
The DS/DNSKEY/RRSIG chain, why validation fails, and the TTL, registrar and migration sequencing that keeps a zone resolvable.
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.
Markdown and Docusaurus: docs-as-code, the content pipeline and the metadata that keeps it alive.
The document tree, the seven content models, the elements that carry meaning, global attributes and the metadata that decides encoding, viewport and language.
The document object model as a programming surface: node types, query and mutation APIs, the capture and bubble flow, delegation, observers and shadow roots.
Strategic and tactical design: bounded contexts, aggregates and the model that survives a rewrite.
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.
Turning a notebook into a parameterized and testable script: arguments and config, logging and exit codes, atomic writes, idempotent runs, validation and scheduling.
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.
Header bytes per layer, the 1500-byte budget, MSS derivation, fragmentation and PMTUD under tunnel overhead.
Playwright and Cypress: driving a real browser, and the flakiness that comes with it.
GDPR and privacy engineering: the data minimisation and retention rules a system has to encode.
error 接口、哨兵错误与自定义类型、%w 包装链、errors.Is/As/Join、panic 与 recover 的同 goroutine 边界、包设计与 internal/ 的导入约束、导入环、服务错误分类与对外错误码,以及导出标识符和弃用注释的兼容性规则、init 失败只能 panic 的处理。
Java 的失败处理:受检与非受检异常的契约,try-with-resources 与抑制异常,异常链的因果关系,以及领域错误在边界上的转换。
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.
Python 的错误处理:异常对象如何沿栈展开并匹配 handler,try/except/else/finally 与 with 的执行顺序,raise from 如何建立根因链,3.11 的异常组如何聚合并发失败,以及捕获、翻译与清理的边界。
Rust 把失败编码进类型:Result 承载可恢复错误、Option 表示缺失、panic 留给不变量破坏,? 与 From 让错误沿调用链携带上下文向上传播。
Ethernet framing, MAC learning, flooding, STP, link aggregation and duplex: how a switch moves frames inside one broadcast domain.
CQRS and event sourcing: the read/write split, the event log and the consistency it buys.
A symptom catalogue that maps each network failure to its layer, decisive evidence and first action.
OpenTelemetry, Prometheus and Grafana: traces, metrics and the signals that explain a failure.
Mixing Java, Kotlin and Scala in one build: the bytecode contract, the guarantees that vanish across the boundary, and how to choose.
Ext4, ZFS and journaling: how a file survives a crash and what fsync actually promises.
Native data collection: the twenty-two input types, constraint validation, labels and grouping, the submit encoding path, and FormData at the boundary.
Elasticsearch: the inverted index, analyzers and the query DSL.
函数作为一等值、多返回值与命名结果、变参打包、闭包捕获与 Go 1.22 的每轮循环变量、defer 的求值顺序与 panic 展开、值接收者复制与指针接收者共享、方法集与接口满足、结构体嵌入与方法提升、方法值绑定接收者的时机、init 的初始化顺序与常见风险、调用求值顺序与 nil 函数调用。
Java 把行为写成方法、lambda、方法引用与函数接口,本页拆解重载解析、变长参数、捕获规则与 invokedynamic 在运行时的真实代价。
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.
Argument binding, closures and decorators, generators, context managers, the exception contract, and the gradual type system that documents all of them.
Rust 把函数与闭包当作可传递的值:fn 项、泛型约束、捕获方式与 Fn 系列 trait 共同决定调用点是内联、单态化还是间接调用。
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.
Shortest paths and minimum spanning trees: which algorithm fits which graph, and where the complexity moves.
Adjacency matrices, adjacency lists, topological sort and union-find: how a graph is stored decides which algorithm is cheap.
CPU instruction sets, the storage hierarchy and network hardware: the latency numbers every design inherits.
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.
How HTTP semantics stay stable while framing, multiplexing and the wire move from HTTP/1.1 to h2 and h3.
Freshness, validators and the shared-versus-private split: how Cache-Control directives, Vary and conditional requests decide reuse, and where invalidation fails.
epoll, io_uring and zero-copy: the readiness and completion models behind a network server.
Read ICMP error and probe traffic, diagnose PMTUD black holes, and reason about NAT mappings, conntrack timeouts and hairpin paths.
B+ tree indexes and execution plans: why a query is slow and which index changes it.
Testcontainers and API mocks: testing the seam between your code and a real dependency.
Read any CIDR, derive subnet boundaries, and allocate non-overlapping IPv4 and IPv6 prefixes for sites, VLANs and containers.
The control plane and the pod lifecycle: how a declared state becomes running containers.
MVC, clean architecture and hexagonal architecture: the dependency rule and where each boundary pays off.
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.
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.
Arrays, linked lists, stacks, queues and hash tables: the storage trade-offs behind every collection API.
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.
Virtual memory, paging and segmentation: the address space, the page table and the cost of a miss.
Kafka, RabbitMQ and Pulsar: the log, the queue and the delivery guarantees between them.
Service discovery, configuration and API gateways: the operational cost of splitting a system.
The Spring Security filter chain, Actuator and Micrometer, startup, probes and graceful shutdown.
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.
Which network signals to instrument, how to aggregate them honestly, and how to turn RTT, retransmits and handshakes into SLOs that page early.
Redis, MongoDB and Neo4j: the data models that justify giving up a relational schema.
接口值为什么不是 nil、隐式满足与方法集规则、typed nil 陷阱、类型断言与类型 switch、消费方小接口,以及泛型的类型参数、comparable 与 ~ 近似项、联合约束、实例化与类型推断、接口与泛型的选型边界和装箱成本、约束接口不能作变量类型、类型参数的编译期检查。
Java 的面向对象:类、接口、记录、枚举与密封层级的取舍,继承与组合的边界,以及分派、equals/hashCode 与脆弱基类的约束。
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.
Python 的面向对象:类如何由类体执行与元类共同创建,属性查找为何先描述符后实例字典,C3 线性化如何决定 MRO 与 super 的走向,以及 dataclass、Protocol、ABC 与组合在动态分派下的分工与边界。
MIT, Apache 2.0 and GPL: what each licence permits, requires and forbids.
The seven-layer and four-layer models as a diagnostic tool: PDU names, encapsulation order and the layer that owns a failure.
Choosing a capture point, writing narrow filters, bounding file size, and reading a handshake or RST without leaking credentials.
Splitting RTT hop by hop, separating queueing from loss, spotting asymmetry, and probing the path MTU.
AES, RSA, hashes, MACs and KDFs: the primitives and the parameters that keep them sound.
Scheduling and context switching: what the OS shares between execution units and what it does not.
Streams, TLS 1.3 integration, 0-RTT, connection IDs and loss recovery: reliability moved into user space over UDP.
TF-IDF and BM25: the scoring functions behind a search result order.
WebSocket, SSE and long polling: upgrade, frames, heartbeats, reconnect, backpressure and the proxy timeouts that break them.
PostgreSQL and MySQL: the relational model, the planner and the operational differences between them.
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.
Viewport units, media and container queries, fluid type with clamp, responsive images, and the transition and animation rules that keep motion cheap and optional.
CRL, OCSP, stapling and CT logs: proving a certificate is still trustworthy after it was issued.
The Spring MVC request path, validation and error mapping, then transactions, JPA and the connection pool behind them.
Read a routing table, choose between static, OSPF and BGP, and debug prefix propagation and route selection across autonomous systems.
When to model a call as a remote procedure, and how protobuf contracts, deadlines, trailers and streaming stay safe under retry.
Go 运行时如何把 goroutine 调度到线程、如何分配内存、如何并发标记回收:GMP、work stealing、mcache/mcentral/mheap、三色标记、写屏障、pacer 与 GOGC/GOMEMLIMIT 的取舍。
Node.js on V8 and libuv: the event loop, the thread pool and the boundary between JavaScript and the OS.
The class file, the loading and linking phases, class loader hierarchy, reflection and the leaks a class loader can hold.
Tiered compilation, inlining and deoptimization, safepoints, the Java Memory Model and how virtual threads change the cost of blocking.
Runtime data areas, allocation, the garbage collectors compared, pause budgets and the OOM types that follow.
Quicksort, merge sort and binary search: the comparison model, stability, and when the input shape changes the right answer.
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.
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.
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.
Flink: event time, watermarks and state in an unbounded stream.
Go 的语法面:25 个关键字、预声明标识符、字面量与运算符、语句形式,以及自动分号插入和版本边界带来的陷阱。
Java 的语法面:50 个关键字、字面量与语句骨架,以及 record、sealed、模式匹配和文本块在 8/11/17/21 上的版本边界。
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.
Python 的语法面:35 个关键字如何划出语句边界,缩进为何是语法而不是风格,推导式、装饰器、海象运算符与 match 各自的求值规则,以及 3.8 / 3.10 / 3.11 / 3.12 的版本门槛。
Rust 的语法把声明、模式解构与类型约束写在同一套表达式规则里,用 match 的穷尽性、? 的短路传播和生命周期标注把控制流与借用范围显式化。
Handshake, the eleven-state machine, byte sequencing, retransmission, flow control and the TIME_WAIT tail of a close.
TLS 1.3 handshake, record layer, resumption and 0-RTT: the session a client and server agree on.
Vite, Webpack, pnpm and Vitest: how source becomes a bundle, a dependency tree and a test result.
Maven lifecycles and POM inheritance, the Gradle task graph, dependency resolution and the rules that make a build reproducible.
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.
The import system, the src layout, pyproject build backends, wheels and sdists, and the environment and lock tools that make a resolution reproducible.
Executable jars, jlink and jpackage, native images, reproducible artifacts and the publish step that follows.
JUnit 5 architecture, the extension model, test doubles, Testcontainers and the surefire and failsafe split.
ACID, MVCC and isolation levels: what a transaction guarantees and what it costs.
Binary trees, red-black trees, B-trees, B+ trees and heaps: the balance and fan-out choices behind ordered data.
A layer-by-layer decision tree that turns refused, timeout, reset and slow into falsifiable hypotheses with the cheapest evidence.
Choose an encapsulation and key exchange, budget the MTU cost, and tell a handshake failure apart from a routing or policy failure.
Go 的值模型:基本类型与零值、显式转换和类型身份、常量与 iota 的求值、string/byte/rune 的 UTF-8 边界、slice 头的 len/cap、append 扩容与别名、map 的引用语义、struct 对齐填充、指针复制语义、可比较规则,以及逃逸分析如何决定栈或堆。
Nominal typing, generics and erasure, null safety and algebraic data types across Java, Kotlin and Scala.
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.
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.
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.
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.
Datagram semantics, the eight-byte header, checksum coverage and the amplification risk of a connectionless protocol.
What a unit test isolates, the assertion libraries that express it, and where Vitest/Jest fits.
The Git object model, branching and the GitHub/GitLab workflows built on top of it.
OWASP Top 10, XSS, CSRF and WAF: the browser threat model and the controls that reduce it.
802.11 framing, CSMA/CA, channels and bands, roaming, WPA2/WPA3 and interference: why wireless throughput is a shared-medium budget.