This article walks through implementing a deep‑copy function in Go with the reflect package, explaining key concepts such as reflect.ValueOf, reflect.New, pointer handling, and recursive copying, and provides a complete code example and visual diagrams.
This article introduces Javaassist, a Java library for runtime bytecode manipulation, and demonstrates how to view compiled bytecode, add Maven dependencies, generate new classes, modify existing ones, insert fields and methods, and apply AOP‑style enhancements without changing source code.
The article examines why Java typically outperforms JavaScript in execution speed, exploring differences in compilation versus interpretation, runtime environments, type systems, and typical use cases, and explains why JavaScript remains indispensable despite its slower performance.
Unlike Taro 1/2, which compiles React code into native mini‑program files through a complex Babel‑based pipeline, Taro 3 runs the original React source at runtime by injecting a lightweight simulated DOM/BOM layer, simplifying development but adding a performance‑overhead that is mitigated with pre‑rendering and virtual lists.
This article explains the Java Virtual Machine's memory architecture—including heap, method area, stack, program counter, and non‑heap memory—details common garbage‑collection algorithms such as mark‑sweep, copying, mark‑compact, and generational, and outlines Java's memory‑management practices like object lifecycle, memory partitioning, references, and synchronization.
This article provides a comprehensive overview of the Java Virtual Machine's runtime memory areas, object layout, garbage collection roots, marking algorithms, generational hypotheses, remembered sets, and the main GC algorithms such as Mark‑Sweep, Mark‑Copy, and Mark‑Compact, explaining their principles and trade‑offs.
This article explains how a Go hello‑world program starts, tracing the ELF entry point, runtime initialization, GMP scheduler setup, creation of the main goroutine, and the flow into the user's main function.
This article explains the Java Runtime addShutdownHook API, its purpose for registering shutdown hooks, typical use cases such as resource cleanup, state saving, and logging, and provides practical Java and Groovy code examples while noting that hook execution order is unspecified.
The article explains Go’s runtime finalizer mechanism, shows how a single blocked finalizer can stall all cleanup callbacks, and recounts a real‑world memory‑leak incident where an unrelated goroutine’s blocked finalizer for struct B prevented struct A’s resources from being released.
This article explains the internal structure of Java class files—including magic numbers, versioning, constant pools, access flags, fields, methods, and attributes—illustrates bytecode generation with a sample class, and details the JVM's class loading, verification, preparation, resolution, initialization, memory allocation, object layout, and execution engine.
This article explores Go's channel implementation—from its CSP‑inspired design and internal hchan structure to real‑world memory‑leak debugging, creation nuances, send/receive mechanics, and proper closing—providing developers with a comprehensive understanding of safe concurrent programming in Go.
The .NET 8 Preview 5 release introduces a DI‑friendly metrics API, built‑in Source Link, a new library analyzer, Linux self‑contained build changes, a composite R2R Docker image, removal of the RID graph, default PGO, and NativeAOT field‑access optimizations, all aimed at improving developer experience and runtime performance.
This article compares the memory management and garbage collection architectures of Java and Go, detailing their heap and stack regions, GC trigger conditions, collection algorithms, fragmentation handling, root object selection, and write‑barrier strategies, and includes illustrative code examples.
This article provides a detailed walkthrough of LocatorJS, covering how to clone the repository, set up the development environment, explore the Chrome extension code, and dissect the runtime implementation that leverages React fiber, SolidJS components, and Babel plugins to enable precise code‑to‑UI mapping.
This article provides a comprehensive overview of the WebAssembly runtime, detailing its binary format, module loading and validation, execution engine designs, linear memory layout, garbage‑collection proposals, and the WebAssembly System Interface (WASI), while illustrating each concept with diagrams and code examples.
This article introduces the core components of WebAssembly engines, outlines a generic engine architecture, and compares five popular engines—wasmtime, wasm3, WasmEdge, wasm‑micro‑runtime, and V8—detailing their design, performance, standards support, and typical use cases.
This article introduces the core components of WebAssembly engines, presents a conceptual architecture model, and then examines several popular open‑source runtimes—including wasmtime, wasm3, WasmEdge, wasm‑micro‑runtime, and V8—detailing their structures, performance characteristics, standards support, and typical use‑cases.
This article explains WebAssembly's execution model, covering import/export fundamentals, language bindings with wit‑bindgen, the waPC protocol, web browser integration, command‑line runtimes like Wasmtime and WasmEdge, embedded use cases such as Wasm3 on Arduino, and how to embed WASM modules in Envoy plugins and languages like Go, Java, and Python.
This article provides a comprehensive overview of WebAssembly, explaining its import/export model, tooling such as wit‑bindgen and waPC, practical examples for web browsers, command‑line runtimes, embedded systems, and plugin architectures, and demonstrates how to integrate WASM with languages like C, Rust, Go, Java, and Python.
This article explains how Android's JVMTI (ART Tooling Interface) works, details its monitoring capabilities, shows how to overcome debug‑only restrictions by modifying JDWP and Runtime flags, and describes the TBProfiler tool that leverages JVMTI for method, thread, exception, lock, and memory profiling in production apps.
This article explains how Go implements its own goroutine scheduler within the runtime, demonstrates it with sample code, and details the GMP (Goroutine‑M‑Processor) model, its scheduling strategies, and the evolution from the earlier GM model.
Go 1.20, released six months after Go 1.19, introduces major toolchain, runtime, and standard library enhancements, adds experimental RISC‑V support, updates syntax with slice‑to‑array conversion and new unsafe functions, and includes numerous performance and build‑system improvements.
This article dissects Go’s select statement, explaining its I/O multiplexing purpose, compile‑time transformation via walkSelect and walkSelectCases, and the multi‑stage runtime algorithm in runtime.selectgo that handles various case patterns, lock ordering, polling randomness, and channel blocking behavior.
This article analyses the inner workings of Objective‑C’s Key‑Value Coding (KVC) by dissecting its setter and getter generation, primitive value handling, NSNumber/NSValue wrapping, and demonstrates advanced usage such as batch property updates, aggregation, and data filtering in real‑world projects.
The article explains Go’s channel implementation as a lock‑protected FIFO queue composed of a circular buffer, send and receive wait queues, detailing creation, send/receive mechanics, closing behavior, a real‑world memory‑leak example, and why this design offers safe, performant concurrency comparable to mutexes.
Docker has released a technical preview of Docker+Wasm, partnering with the Bytecode Alliance and WasmEdge to add a containerd shim that runs WebAssembly modules, providing faster startup, smaller binaries, and a new runtime flag, while offering example commands and download links for early adopters.
Noslate is Alibaba’s new open‑source, cloud‑native serverless JavaScript runtime that combines a custom cold‑start‑optimized Node.js distribution, the Aworker container with Warmfork and V8 startup snapshots for sub‑millisecond launches, a Noslated control plane for flexible worker orchestration, and a Corefile‑based debugger for low‑impact diagnostics.
Docker unveils a technical preview of Docker+Wasm, integrating WebAssembly into its container engine via a new containerd shim, offering faster startup, smaller binaries, and a seamless workflow for building and running Wasm applications, while joining the Bytecode Alliance to advance WASI standards.
Noslate is an open‑source, cloud‑native suite comprising a custom Node.js distribution, the lightweight Aworker runtime with Warmfork and Startup Snapshot technologies, all designed to dramatically reduce cold‑start latency and improve JavaScript task elasticity in serverless environments.
Noslate is an open‑source, cloud‑native project from Alibaba that introduces a lightweight JavaScript runtime, optimized Node.js distribution, and an offline debugger to dramatically reduce cold‑start latency, improve elasticity, and simplify diagnostics for serverless workloads across diverse architectures.
This article explains how Go’s goroutine scheduler works, covering the fundamentals of OS thread scheduling, the transition from the old G‑M model to the modern G‑P‑M model, pre‑emptive scheduling strategies, lifecycle details, practical debugging tools, and performance‑related design choices.
Pyston 2.3.5, a fork of CPython 3.8 maintained by Anaconda, delivers double‑digit performance gains for network‑service workloads, offers two‑fold speedups on micro‑benchmarks like chaos.py and nbody.py, and remains highly compatible with the full CPython feature set and C API.
This article explains how to create a lightweight, embeddable JavaScript runtime using Duktape, compile it to WebAssembly, expose custom APIs, and integrate it into a web-based login greeter, highlighting implementation steps, code examples, and potential use cases.
The article explains how Go’s runtime manages goroutine stacks—starting with a 2 KB initial size, evolving from segmented to continuous stacks, detailing allocation via stackpool and stackLarge, expansion with runtime.newstack, shrinkage by the garbage collector, and the internal structures that coordinate these processes.
Bun is a modern JavaScript runtime built on WebKit’s JavaScriptCore instead of V8, backed by $7 million funding, and its creators aim to release a stable version within six months, positioning it as a potential alternative to Node and Deno.
This article explains how Go pointers work, why they differ from C pointers, and highlights frequent mistakes such as struct pointer assignments, for‑range loop quirks, closure captures, and memory‑escape scenarios, providing clear code examples and runtime insights.
To enable encrypted transmission and traffic monitoring across multiple iOS apps with diverse networking frameworks, this article compares several network AOP solutions—including AFNetworking, Moya, custom frameworks, runtime method swizzling, and NSURLProtocol—evaluates their pros and cons, and details the chosen NSURLProtocol-based implementation with plugin architecture.
This article demystifies the JVM’s runtime data areas and illustrates, with a simple Java example and animation, how a program’s bytecode is executed—from the program counter and stack frames to heap allocation and garbage collection—providing a clear, step‑by‑step view of Java execution.
This article provides a comprehensive analysis of Go's map implementation, covering its hash‑table foundation, key type constraints, hash function characteristics, collision resolution strategies, runtime initialization, internal structures like hmap and bmap, and the various operations for creation, access, update, deletion, and resizing.
This newsletter curates recent technical insights covering the high‑performance Bun JavaScript runtime, ESM Loader Hooks for module processing without bundlers, deep dives into Canvas and CSS graphics, practical guides on unit testing, serverless deployment, and advanced JavaScript features like Proxy and Reflect, offering developers a comprehensive overview of modern frontend engineering trends.
Bun, a modern JavaScript runtime built on WebKit's JavaScriptCore, offers faster execution, built‑in Web APIs, TypeScript support, bundling, and npm compatibility, positioning itself as a high‑performance alternative to Node and Deno for server, edge, and local development.
Based on Google’s TCMalloc, Go’s automatic memory system organizes memory into pages and spans, uses per‑processor mcache and shared mcentral for size‑class allocation, and employs a concurrent tri‑color mark‑sweep garbage collector triggered by heap usage or large allocations, illustrating the full allocation‑to‑reclamation pipeline.
This article explains why traditional pprof sampling often fails in production, introduces Go's built‑in profiling tools and runtime.pprof, defines practical rules for triggering automatic sampling based on resource spikes, and demonstrates using the open‑source Holmes library and Docker demo to collect self‑diagnostic profiles.
This article explains how Objective‑C implements weak pointers using a hash‑based weak table, SideTables, ExplicitInit, and various low‑level C++ template functions such as storeWeak, weak_register_no_lock, and weak_clear_no_lock to ensure automatic nil‑assignment and safe deallocation.
This article explains the various execution states of Serverless Task, the state‑transition flow, runtime instance management, and how to gracefully stop tasks using PreStop hooks and SDK calls, providing practical guidance for cloud‑native developers.
This article explores how to reduce Go's heavy runtime by replacing its entry point, demonstrates building a minimal Go runtime, implements a simple Python JIT compiler in Go, and shows how to create a self‑hosted Go compiler using LLVM IR, complete with code examples and optimizations.
The article demonstrates three advanced Go techniques—eliminating the standard runtime by custom entry points, building a simple Python JIT compiler that translates bytecode to optimized machine code, and bootstrapping the Go compiler itself via AST‑to‑LLVM translation—offering practical code examples that reveal compiler internals.
tmagic-editor is a WYSIWYG visual editor that enables zero‑code/low‑code creation of H5, PC, and TV pages, offering a drag‑and‑drop workflow, component runtime support for Vue2/Vue3/React, and a management demo for page publishing and customization.
This article introduces the ShadowRealm API, a new JavaScript proposal that creates independent, highly isolated realms for executing code, explains its type signatures, demonstrates .evaluate() and .importValue() methods with practical examples, and compares it with eval, Web Workers, iframes, and Node.js vm.
This article explains why Go programs can still exhibit memory growth despite automatic garbage collection, describes how to identify and diagnose such issues with the built‑in pprof tool, and details the underlying sampling mechanism, memory fragmentation, and cgo‑related allocations.
This guide explains why enabling .NET Framework may still leave applications unable to run, details the need to install both .NET Runtime and SDK for versions 5.0 and 6.0 in x86 and x64, and provides step‑by‑step troubleshooting with a real‑world example.
The article reviews Dmitry Vyukov's 2019 talk on Go's goroutine scheduler, explains the GMP (goroutine‑M‑Processor) model, walks through its evolution from naive thread‑per‑goroutine to thread pools and work‑stealing, and discusses fairness, pre‑emptive scheduling, and possible future improvements.
This article explains the fundamental principles behind JavaScript execution, covering the distinction between interpreted and compiled languages, the architecture of JavaScript engines (including V8, SpiderMonkey, and JavaScriptCore), runtime environments, the single‑threaded event loop, call‑stack processing, lexical analysis, parsing, bytecode, JIT compilation, and the role of Web Workers in off‑loading CPU‑intensive tasks.
The article explains how Ponder’s C++ reflection library uses template‑based type erasure to register and invoke functions at runtime, detailing the Function class, registration syntax, argument conversion, Lua integration, performance considerations, and a complete Vector3 DotProduct example.
The article dissects the Ponder C++ reflection library’s Property subsystem, explaining how registration via ClassBuilder creates property entries, how traits and ValueBinders map members to abstract Property objects, and how runtime Get/Set calls traverse templated binders to provide type‑safe, high‑performance access.
The article explains how to implement a runtime reflection system for C++ using the Ponder library, detailing type registration, property and function metadata, builder-generated meta‑objects, type‑erasure wrappers like UserObject and Value, and runtime APIs for dynamic object creation and invocation.
Go implements a two‑level N:M concurrency model where lightweight Goroutines (G) run on logical processors (P) backed by OS threads (M), with the GMP scheduler managing run queues and channels—mutex‑protected circular buffers with send/receive queues—providing efficient, preemptive multitasking and communication.
Java reflection lets programs inspect and manipulate classes, methods, and fields at runtime, enabling dynamic object creation, method invocation, and flexible framework design; this guide explains its definition, benefits, underlying mechanics, practical usage with code examples, and common scenarios such as JDBC driver loading and Spring IoC.
This article explains how Go's garbage collection has progressed from the simple stop‑the‑world mark‑and‑sweep algorithm in Go 1.3, through the tri‑color concurrent marking with insert and delete write barriers in Go 1.5, to the hybrid write‑barrier approach introduced in Go 1.8 that dramatically reduces pause times while preserving memory safety.
This article provides a comprehensive analysis of iOS's Key-Value Observing (KVO) mechanism, covering its fundamentals, registration and observation steps, underlying isa‑swizzling implementation, usage patterns, common pitfalls, debugging techniques, and alternative solutions such as custom KVO implementations and the KVOController library.
This article dives deep into Go's channel implementation, explaining the hchan data structure, how make creates channels, the send/receive mechanics, goroutine scheduling, blocking behavior, and provides practical code examples to illustrate these concepts.
CRI shim is a gRPC server that implements the Container Runtime Interface, enabling kubelet to manage pod and container lifecycles, network via CNI, and streaming APIs like Exec, Attach, and PortForward, with detailed explanations of RuntimeService, ImageService, and the CRI‑containerd architecture.
The article examines how visual page‑building platforms evolve from simple component libraries into full‑stack, low‑code solutions by separating UI and logic, introducing a DAG‑based DSL, and implementing a lightweight runtime that lets non‑developers configure and execute front‑end workflows, dramatically boosting development efficiency.
Version 2.098.0 of the D programming language has been released, featuring DMD 2.098.0 and LDC 1.28.0 compilers, OpenBSD support, 17 major compiler changes, runtime improvements, library updates, and Dub enhancements, along with 160 issue fixes.
This article explains how the V8 engine parses JavaScript source code into an AST, establishes scope rules, creates isolates, handle scopes and contexts, and manages the execution context stack during interpretation and execution, illustrated with detailed code examples and diagrams.
The 2021 Sysdig report analyzes millions of containers to uncover short lifespans, shifting runtime choices, rising use of Prometheus, prevalent security misconfigurations, image‑scanning practices, and emerging threats, offering actionable insights for organizations managing cloud‑native workloads.
This comprehensive guide covers network layer protocols like IP and its address classes, transport layer details of TCP and UDP, socket programming basics, the full compilation and linking process, and the creation and usage of shared libraries and DLLs across Linux and Windows.
The article details Go’s runtime memory architecture—including pages, spans, mcache, and size classes—and explains its non‑generational concurrent tri‑color mark‑and‑sweep garbage collector, the required write‑barrier techniques, and the collector’s evolution, phases, trigger mechanisms, and practical code examples across Go 1.0‑1.16.
An in‑depth troubleshooting story reveals how a container engine restart broke the FIFO used for stdio forwarding, causing a Java app to hang; the fix was simply changing the FIFO open mode from O_WRONLY to O_RDWR, and the article explains the underlying container I/O architecture.
This article explains how Go executables receive and process command‑line arguments and environment variables, compares C and Go implementations, dives into the Linux stack layout, and details the flag package's parsing mechanics with code examples and runtime internals.
This article explains the internal structure of Objective‑C categories, how they are represented as structs in the runtime, the process by which the Mach‑O loader discovers and attaches them, and the distinct execution order of their +load and +initialize methods.
This article explains Go's MPG scheduling model, detailing how Goroutine, M, and P interact during blocking, asynchronous and synchronous system calls, the role of the netpoller, and the sysmon coroutine that enables preemptive scheduling and runtime monitoring.
This comprehensive guide breaks down the CNCF cloud native landscape into its four core layers—Provisioning, Runtime, Orchestration & Management, and Application Definition—explaining the problems each layer solves, the key technologies involved, and how they interoperate to enable modern, scalable applications.
This article explains how Java source files are compiled into bytecode, how the JVM loads and links classes, and details the roles of lexical, syntax, and semantic analysis, as well as the classloader hierarchy and the parent‑delegation mechanism.
This article explains Kubernetes' deprecation of Docker, introduces containerd as a lightweight, industry‑standard runtime, and provides step‑by‑step instructions for installing, configuring, and operating containerd on Linux, including common CLI commands for managing images and containers.
This article explores how Go implements the empty interface (interface{}) at the binary level, detailing stack frame allocation, compiler‑generated helper functions, pointer structures, and runtime optimizations that together reveal why an empty interface is essentially two consecutive pointers in memory.
This article provides a detailed examination of the YYModel framework’s source code, explaining how it leverages Objective‑C runtime to parse JSON into model objects, covering key files, internal classes, mapping mechanisms, and the core conversion methods with illustrative code examples.
This article explores how visual page‑building systems, component reuse, and a DSL‑driven logic orchestration platform together break development bottlenecks, enabling non‑engineers to contribute to page creation while maintaining a lightweight, extensible runtime for front‑end applications.
This article details Ant Group's evolution from monolithic applications to microservices and its large‑scale adoption of Service Mesh, describing the motivations, challenges, architecture, multi‑mesh capabilities, and the design of a cloud‑native application runtime built on MOSN to decouple applications from infrastructure.
This article provides an in‑depth technical analysis of Webpack's runtime, explaining how bundles are composed of business code and runtime, the generation of __webpack_require__ helpers, the mechanisms behind asynchronous chunk loading, hot module replacement, and the internal dependency‑collection process that drives the final asset emission.
This article explains how Swift and Objective‑C can be mixed in iOS projects, covering prerequisite settings, CocoaPods module configuration, name mangling, compilation differences, dynamic features, method replacement techniques, and the underlying Swift runtime metadata that enable seamless inter‑language calls.
This article explains a novel Swift hooking technique that modifies the virtual function table (VTable) to replace method implementations, detailing Swift's runtime structures such as TypeContext, Metadata, OverrideTable, and providing concrete ARM64 assembly and Swift code examples.
Released in October 2020, Pyston v2 is a JIT‑based Python implementation that delivers roughly 20% speed improvements over CPython 3.8 in macro‑benchmarks, offers easy deployment, maintains high compatibility with CPython, and incorporates techniques such as DynASM JIT, quickening, and process‑building optimizations.
This article explores the theoretical and practical limits of Java String length, analyzing JDK source code, integer ranges, JVM constant pool constraints, and runtime memory considerations to reveal why the maximum size is 2^31‑1 characters (≈4 GB) at runtime but only 65 534 characters at compile time.
At an April 10 technical salon, iQIYI’s Zhao Wei detailed the company’s shift from Mesos‑Marathon to Kubernetes, describing container application scenarios, evolving network stacks from bridge/NAT to Cilium/BGP, the adoption of Containerd with RunC and optional Kata runtimes, performance trade‑offs, and a hybrid scheduling approach that improves resource utilization across offline and online services.
This article explains how an iOS/macOS application is launched, detailing the interaction between dyld and the Objective‑C runtime, the initialization steps performed by _objc_init, and the series of functions such as environ_init, static_init, map_images, read_images, and load_images that together realize classes, selectors, protocols and +load methods before main() is called.
This article explains why Babel 6 and Babel 7 produce typical errors such as "regeneratorRuntime is not defined" and "Cannot find module 'core-js/library/fn/**'", then walks through the roles of @babel/preset‑env, @babel/plugin‑transform‑runtime, core‑js versions, useBuiltIns options, and provides concrete configuration examples for both application and library projects.
This article explains why reading the ART virtual‑machine source is valuable, compares Dalvik and ART, outlines the GC source hierarchy, details the Space class architecture—including accounting, allocator, collector, and specific spaces like LargeObjectSpace, BumpPointerSpace, and RegionSpace—then analyzes heap construction, PreZygoteFork processing, memory‑map layout, and the full Java‑object allocation flow in ART.
This article explains why front‑end performance optimization is crucial for user retention and conversion, outlines loading‑time and runtime optimization categories, and provides practical techniques such as DNS prefetching, HTTP/2 adoption, resource compression, lazy loading, virtual lists, event delegation, and code‑level best practices with concrete code examples.
Version 2.096.0 of the DMD compiler has been officially released, introducing 17 major changes across the compiler, runtime, standard library, and Dub integration, fixing 81 bugs, adding new types and compiler switches, updating JSON output, and deprecating several features.
This article details the background, design choices, runtime architecture, code transformation, entry and page support, lifecycle handling, and integration strategy of adapting the Taro 3 framework to run on React Native, providing a comprehensive guide for cross‑platform development.
The article details Go’s G‑M‑P scheduler, showing how lightweight Goroutines (G) run on OS threads (M) bound to virtual processors (P), describing runtime initialization, run‑queue management, work‑stealing, the main schedule loop, execution binding, and cleanup via goexit.
This article explores Swift’s binary representation by comparing it with Objective‑C, demonstrating runtime dynamic method invocation, dissecting Mach‑O sections such as __objc_classlist and __swift5_types, and revealing how Swift classes store their metadata and VTables.
This article examines Swift's binary representation in Mach-O files, compares it with Objective‑C storage, demonstrates runtime dynamic method calls, and analyzes class metadata, VTable construction, and related flags to reveal how Swift functions are located and invoked at runtime.
This article explains Java's generic type erasure, why it exists, and demonstrates how to use Gson's TypeToken and reflection APIs to obtain actual generic type information at runtime, complete with code examples and a detailed walkthrough of the underlying mechanism.
This article explains how Objective‑C objects are deallocated in both manual reference counting (MRC) and Automatic Reference Counting (ARC), outlines common pitfalls such as using __weak in dealloc, and details the runtime flow from _objc_rootDealloc to the final memory free operation.
This article walks through Vue 3's initialization process, explaining what createApp(App).mount('#app') does, how the runtime‑dom and runtime‑core modules create and render VNodes, and how patch, shapeFlags, and patchFlags drive efficient DOM updates.
This article explains the principles behind Rax's mini‑program runtime scheme, compares it with the compile‑time approach, details the self‑referencing component technique, event system, engineering design, performance tuning measures, mixed usage with custom components, and future optimization directions.