This article explains the fundamentals of Aspect‑Oriented Programming on iOS, compares major AOP techniques such as Method Swizzle, Aspects, MPSwizzler, ISA‑swizzle KVO, Fishhook, Thunk and Clang instrumentation, and provides practical code examples and best‑practice guidelines.
The article introduces the Thanos framework, a Vue‑based compile‑time solution that enables cross‑platform development for nine mini‑program and web targets by unifying components, APIs, and runtime behaviors, and details its architecture, scaffold tools, compiler mechanics, and runtime optimizations.
Node.js 15, the latest runtime release, replaces Node.js 14 as the active line, introduces npm 7 with workspace and peer‑dependency auto‑install, switches unhandled promise rejections to throw mode, adds N‑API 7, updates V8 to 8.6, and includes QUIC support, though it is not yet LTS and isn’t recommended for production.
This article explains how Objective‑C creates objects by detailing the two creation methods, the internal alloc and init implementations, the callAlloc workflow, memory allocation, and the final binding of the isa pointer, with full source code excerpts for each step.
This article explains Java reflection, describing its ability to inspect and modify classes at runtime, the core reflection classes, practical use cases, performance considerations, and provides comprehensive code examples that demonstrate class, method, field, and interface introspection.
This article provides a comprehensive overview of the Java Virtual Machine runtime data area, detailing each memory partition—including the JVM stack, native method stack, heap, method area, and program counter—and explains the concept and usage of direct memory.
Lokie is a high‑performance iOS AOP framework written in C++14 that replaces the slow Aspect library by using libffi‑based trampolines, offering thread‑safe method interception, detailed API usage, runtime internals, and assembly‑level trampoline implementation with significant speed improvements.
This article examines the evolution of WeChat mini‑programs, compares native syntax with progressive enhancement, compile‑time conversion and runtime frameworks, and offers guidance on selecting the most suitable approach based on performance, syntax flexibility, and business needs.
This article provides a comprehensive source‑level examination of Go's channel mechanism—including usage examples, the internal hchan data structure, creation, read/write operations, closing behavior, and common pitfalls—based on the Go 1.14 runtime implementation.
This article explains Java's reflection mechanism, showing how classes are represented by Class objects, how to obtain them at runtime, and demonstrates common reflective operations such as inspecting fields, constructors, methods, and arrays with practical code examples and typical interview questions.
This article explains how iOS developers can use the Objective‑C runtime to automatically convert dictionaries to model objects, add properties to existing classes via associated objects, and implement method swizzling for tasks such as analytics injection, illustrating each technique with code flow and diagrams.
Associated ObjectsDictionary to ModelMethod Swizzling
This article explains the internal data structures of the Objective‑C runtime, covering objc_object, objc_class, class_data_bits_t, class_rw_t, and class_ro_t, and illustrates how these structures define objects, classes, method caches, and associated metadata in iOS development.
The article details Meituan’s Flap system, a static‑DSL‑based dynamic Flutter architecture that converts Dart code into JSON, loads it at runtime, and delivers cross‑platform, low‑cost, high‑performance updates, reducing package size and release cycles while preserving native Flutter rendering quality.
This article explains what Key-Value Observing (KVO) is, how to use it in iOS development, and the runtime mechanisms—such as isa‑swizzling and dynamic subclass creation—that enable automatic property change notifications, while also showing how to build a custom KVO system.
This article provides a comprehensive overview of the Java Virtual Machine (JVM) architecture, detailing its garbage collection mechanisms, class‑loader subsystem, execution engine, runtime data areas, and common GC command‑line options, offering essential knowledge for Java developers.
This article introduces the Sunglasses crash investigation tool, explains iOS Objective‑C runtime message handling—including method lookup, dynamic resolution, and forwarding—details method swizzling implementation with code examples, and discusses class clusters and future enhancements for mobile development debugging.
This article explains what Dex2OAT is, why ahead‑of‑time compilation improves Android performance, the related file formats, command‑line usage, log analysis, system configuration, the internal call flow in Android Q, and practical optimization strategies for smoother app experiences.
This article provides a comprehensive guide to Java's reflection mechanism, covering its definition, core capabilities, practical code examples, common API usage, and considerations such as performance and security, enabling developers to understand and apply reflection effectively in real-world projects.
This guide explains what the Objective‑C runtime is, where to obtain its source code, the required build environment, step‑by‑step compilation instructions, and detailed solutions for the numerous build errors encountered when compiling objc4 on macOS.
This article explains how to implement method‑execution time monitoring on iOS by hooking objc_msgSend using fishhook and custom assembly, detailing the concepts of hooks, the dyld symbol‑rebinding process, and providing complete code examples for building the QiLagMonitor tool.
This article explains how iOS Key-Value Observing works under the hood, enumerates common pitfalls across iOS versions, and shows how the open‑source KVOController library mitigates those issues while providing safer, block‑based observation APIs.
This article analyzes Go's duck typing and interface mechanisms, explaining how interfaces are defined, implemented, and converted at runtime, including details of underlying structures like iface and eface, method sets, pointer vs value receivers, and type assertions, supplemented with code examples and assembly insights.
This article explains Java annotation fundamentals, explores built‑in meta‑annotations, demonstrates how to create compile‑time and runtime custom annotations, and shows how to integrate them with Spring Boot AOP for automatic logging and request handling.
This article explores how Objective‑C objects are converted to low‑level C/C++ structures, compares the results of class_getInstanceSize, malloc_size and sizeof, and explains memory‑alignment rules, member ordering, padding, and inheritance effects on the actual memory footprint of iOS objects.
WebAssembly, now an official W3C web standard, provides a binary, memory‑safe sandbox for compiling languages like C/C++/Rust to run at near‑native speed in browsers and other environments, dramatically improving web performance and expanding the possibilities of web applications.
This article breaks down iOS's memory layout—including stack, heap, static, data, and text sections—and examines three key management techniques: Tagged Pointers, non‑pointer isa, and SideTables, detailing their implementation, benefits, and underlying data structures.
This article explains containerd’s evolution, its advantages over Docker Engine in Kubernetes, how to set it up with Minikube, use gvisor sandbox, manage containers with ctr and crictl, and outlines Alibaba Cloud’s support for containerd in ACK.
This article explains the Java Virtual Machine’s memory layout, covering the five runtime regions—heap, method area, JVM stacks, native method stacks, and program counter—along with their purposes, thread‑visibility, garbage‑collection behavior, and common pitfalls such as OutOfMemoryError and StackOverflowError.
This article explains Go's garbage collection mechanism, describing its Mark‑Sweep model, the three collection phases, latency implications, and practical tips for reducing pause times through memory‑pressure reduction and runtime debugging tools.
AoE (AI on Edge) is Didi’s open‑source runtime that unifies edge inference frameworks such as NCNN and TensorFlow Lite behind stable, easy‑to‑use and secure interfaces, isolates native code in a separate Android process, offers pre‑/post‑processing abstractions, provides Android/iOS SDKs, and invites developers to contribute via its GitHub repository.
This article explains how Swift objects are created and destroyed, how method calls are implemented compared with Objective‑C, the memory layout of Swift classes, the role of virtual tables, the impact of compiler optimizations, and the feasibility of runtime method replacement, illustrated with extensive C‑style pseudocode examples.
This article provides an in‑depth examination of Android's ClassLoader architecture, explaining how BaseDexClassLoader.findClass() and ClassLoader.loadClass() locate and load classes, with step‑by‑step source code analysis of loadClass, findLoadedClass, findClass, DexPathList, DexFile, and native class definition processes.
This article introduces 360’s iOS mobile performance monitoring solution, QDAS‑APM, detailing its background, monitored metrics such as page rendering time, main‑thread stalls, network errors, FPS, CPU, memory, crash and startup duration, and explains implementation techniques using KVO, runtime class traversal, and code snippets.
This article explores Go's goroutine implementation by dissecting the M‑P‑G model, scheduling strategies, preemption mechanisms, and low‑level context‑switch details, complemented with code snippets and assembly examples to illustrate how lightweight user‑level threads achieve high concurrency.
This article explores Deno—a runtime created by Node.js co‑founder Ryan Dahl—covering its recent releases, TypeScript support, security roadmap, and how it aims to replace Node.js as a modern, secure backend platform.
Facebook's HHVM team announced that version 3.30 will be the last to support PHP, outlining a timeline for dropping PHP, recommending migration to Hack or PHP 7, and detailing 2018‑19 open‑source plans to ease the transition and improve tooling.
This article provides an in‑depth exploration of the Objective‑C runtime, covering the underlying object model, class and metaclass structures, the isa_t layout, how classes are loaded and initialized, dynamic loading mechanisms, and practical applications such as ORM and automatic NSCoding implementation.
This article explores the low‑level implementation of Objective‑C objects by examining instance memory allocation, the differences between class_getInstanceSize and malloc_size, the internal structures of instance, class, and meta‑class objects, and how isa and superclass pointers link them together.
Deno, the open‑source, V8‑based TypeScript runtime launched by Node.js creator Ryan Dahl, aims to correct the design errors he perceives in Node.js by offering a simple module system, built‑in TypeScript parsing, runtime safety, and Go‑based glue, making it a promising, though not definitive, successor.
This article explains the inner workings of Go's runtime scheduler, detailing how lightweight goroutines (G), logical processors (P), and OS threads (M) interact, how work stealing operates, and how to trace scheduler behavior using GODEBUG and go tool trace.
This article provides a comprehensive overview of the Java Virtual Machine, covering its role in Java's cross‑platform execution, internal architecture including class loaders, runtime data areas, execution engine, memory management, and generational garbage collection mechanisms.
This article explains how Android P’s DP1 preview restricts non‑SDK API usage by detailing the hidden‑API greylist mechanism, the compilation‑time processing that marks methods and fields in dex files, and the runtime checks performed by the ART virtual machine to enforce these restrictions.
This article explains Java's reflection mechanism, describing how Class objects represent runtime types, how to obtain them, and demonstrating common reflective operations such as inspecting methods, accessing fields, invoking constructors, handling arrays, and solving typical exercises with complete code examples.
This article critically examines Go’s advertised sub‑10 ms garbage‑collection pauses, compares its concurrent mark‑sweep collector with Java’s GC algorithms, and explores the fundamental trade‑offs of throughput, pause time, memory overhead, and scalability that shape modern garbage‑collector design.
This article provides a detailed technical walkthrough of how the Xposed framework replaces the Android Zygote process, initializes its runtime, registers services, and hooks methods by examining the main, initialize, startAll, and onVmCreated functions along with installation steps.
This article explains how to configure client‑side and server‑side Connect Time Load Balancing for Oracle RAC across versions, details the role of SCAN, local_listener and remote_listener settings, describes Runtime Connection Load Balancing with FAN and LBA events, and shows how to tune TCP timeout parameters.
This article explains the iOS message‑sending and forwarding mechanisms—including dynamic, fast, and normal forwarding—and demonstrates how BlocksKit leverages these mechanisms to implement dynamic delegates using blocks, with detailed code examples and class descriptions.
This article explains key Java concepts such as compile‑time constant folding, the distinction between compile‑time and runtime calculations, method overloading versus overriding, generics type erasure, annotations, exception handling, and aspect‑oriented programming, while illustrating each topic with clear code examples.
Docker 1.10.2 has been officially released, bringing a series of fixes and enhancements across runtime, distribution, networking, volumes, and security components, along with updated download links for various platforms.
JSPatch is an open‑source iOS dynamic‑update framework that leverages Objective‑C runtime and JavaScriptCore to let developers call and replace native methods via JavaScript, with detailed explanations of its core principles, method invocation, replacement, struct and C‑function support, and advanced implementation tricks.
The article reports on DockerCon 2015, summarizing expert viewpoints from JD, Weibo, and a startup founder on Docker’s platform direction, extensions, open standards, production readiness, resource management, and its evolving role as an app‑container versus OS‑container technology.
The article explains Objective‑C categories by detailing their definition, compile‑time vs runtime differences, internal struct representation, how the compiler emits metadata, the loading and +load ordering process, method overriding mechanics, and the use of associated objects for adding state.
This article explains why the “Unrecognized selector sent to instance xxx” crash occurs in Objective‑C, outlines the three stages of the runtime message‑forwarding process, and provides concrete code examples for dynamic method resolution, fast forwarding, and standard forwarding to reliably prevent such crashes in iOS apps.
The article explains how io.js emerged as a community‑driven fork of Node.js in early 2015 to address release frequency and governance concerns, describing its open management model, weekly release plans, compatibility with the npm ecosystem, and the broader context of Node Forward and community reactions.