BestHub
Sign in
Tagged articles

runtime

245 articles · Page 2 of 3
JD Tech
JD Tech
Aug 14, 2023 · Fundamentals

Understanding Java Class File Structure and JVM Loading Process

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.

BytecodeJVMMemoryManagement
0 likes · 26 min read
Understanding Java Class File Structure and JVM Loading Process
FunTester
FunTester
Jul 28, 2023 · Fundamentals

Unveiling Go’s Channel: Deep Dive into Runtime, Memory Leaks, and Best Practices

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.

Gochannelconcurrency
0 likes · 31 min read
Unveiling Go’s Channel: Deep Dive into Runtime, Memory Leaks, and Best Practices
Laravel Tech Community
Laravel Tech Community
Jun 15, 2023 · Backend Development

.NET 8 Preview 5 Released: New SDK Features, Alpine ASP.NET Docker Image, and Performance Enhancements

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.

.NETDockerPerformance
0 likes · 4 min read
.NET 8 Preview 5 Released: New SDK Features, Alpine ASP.NET Docker Image, and Performance Enhancements
FunTester
FunTester
Jun 9, 2023 · Fundamentals

Comparison of Java and Go Garbage Collection Mechanisms

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.

Garbage CollectionJavaMemory Management
0 likes · 13 min read
Comparison of Java and Go Garbage Collection Mechanisms
政采云技术
政采云技术
May 24, 2023 · Frontend Development

LocatorJS Source Code Analysis: Architecture, Chrome Extension Integration, and Runtime Mechanics

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.

Babel PluginChrome ExtensionLocatorJS
0 likes · 11 min read
LocatorJS Source Code Analysis: Architecture, Chrome Extension Integration, and Runtime Mechanics
ByteDance Web Infra
ByteDance Web Infra
May 9, 2023 · Fundamentals

WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC

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.

CompilationGarbage CollectionMemory Management
0 likes · 34 min read
WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC
ByteFE
ByteFE
Apr 24, 2023 · Backend Development

An Overview of WebAssembly Engines: Architecture, Common Implementations, and Comparative Analysis

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.

EnginePerformanceWasmEdge
0 likes · 18 min read
An Overview of WebAssembly Engines: Architecture, Common Implementations, and Comparative Analysis
ByteDance Web Infra
ByteDance Web Infra
Apr 18, 2023 · Fundamentals

WebAssembly Runtime Mechanisms and Practical Usage Across Environments

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.

Proxy-WASMWasmWasmEdge
0 likes · 22 min read
WebAssembly Runtime Mechanisms and Practical Usage Across Environments
ByteFE
ByteFE
Apr 17, 2023 · Fundamentals

Understanding WebAssembly: Runtime Mechanisms, Tooling, and Cross‑Environment Usage

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.

Cross‑PlatformWasmWasm-bindgen
0 likes · 25 min read
Understanding WebAssembly: Runtime Mechanisms, Tooling, and Cross‑Environment Usage
Alibaba Terminal Technology
Alibaba Terminal Technology
Mar 16, 2023 · Mobile Development

Unlock Android JVMTI: Bypass Debug Limits and Build Powerful Profilers

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.

AndroidJVMTIMemory
0 likes · 25 min read
Unlock Android JVMTI: Bypass Debug Limits and Build Powerful Profilers
Laravel Tech Community
Laravel Tech Community
Feb 2, 2023 · Fundamentals

Go 1.20 Release Highlights: New Toolchain, Runtime, and Library Features

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.

Programming LanguageToolchainruntime
0 likes · 5 min read
Go 1.20 Release Highlights: New Toolchain, Runtime, and Library Features
JD Tech
JD Tech
Dec 21, 2022 · Fundamentals

Understanding Key‑Value Coding (KVC) in Objective‑C: Principles, Execution Flow, and Advanced Applications

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.

KVCKey-Value CodingNSValue
0 likes · 15 min read
Understanding Key‑Value Coding (KVC) in Objective‑C: Principles, Execution Flow, and Advanced Applications
Tencent Cloud Developer
Tencent Cloud Developer
Nov 28, 2022 · Backend Development

Understanding Go Channels: Implementation, Usage, and Performance

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.

GoPerformancechannel
0 likes · 29 min read
Understanding Go Channels: Implementation, Usage, and Performance
DaTaobao Tech
DaTaobao Tech
Oct 31, 2022 · Cloud Native

Introducing Noslate: A Cloud‑Native Serverless JavaScript Runtime

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.

DebuggingNode.jsPerformance
0 likes · 13 min read
Introducing Noslate: A Cloud‑Native Serverless JavaScript Runtime
MaGe Linux Operations
MaGe Linux Operations
Oct 30, 2022 · Cloud Native

How Docker+Wasm Is Transforming Container Runtime with WebAssembly

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.

DockerWasmEdgeWebAssembly
0 likes · 5 min read
How Docker+Wasm Is Transforming Container Runtime with WebAssembly
Node Underground
Node Underground
Oct 13, 2022 · Cloud Native

How Noslate Boosts JavaScript Performance for Cloud‑Native Serverless Apps

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.

DebuggingNode.jsServerless
0 likes · 16 min read
How Noslate Boosts JavaScript Performance for Cloud‑Native Serverless Apps
MaGe Linux Operations
MaGe Linux Operations
Oct 11, 2022 · Fundamentals

Inside Go’s Goroutine Scheduler: Concepts, Evolution, and Design

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.

concurrencyg-p-m modelgoroutine
0 likes · 28 min read
Inside Go’s Goroutine Scheduler: Concepts, Evolution, and Design
21CTO
21CTO
Oct 2, 2022 · Backend Development

Pyston 2.3.5 Boosts Python Performance with Major CPython Compatibility

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.

JITPystonPython
0 likes · 4 min read
Pyston 2.3.5 Boosts Python Performance with Major CPython Compatibility
ELab Team
ELab Team
Sep 24, 2022 · Frontend Development

Building a Tiny Custom JavaScript Runtime with Duktape and WebAssembly

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.

DuktapeJavaScriptWebAssembly
0 likes · 8 min read
Building a Tiny Custom JavaScript Runtime with Duktape and WebAssembly
Tencent Cloud Developer
Tencent Cloud Developer
Sep 14, 2022 · Backend Development

Understanding Go Stack Memory Management

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.

GoMemory Managementruntime
0 likes · 15 min read
Understanding Go Stack Memory Management
JavaScript
JavaScript
Sep 1, 2022 · Backend Development

What Makes Bun the Next‑Generation JavaScript Runtime?

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.

BunJavaScriptNode alternative
0 likes · 1 min read
What Makes Bun the Next‑Generation JavaScript Runtime?
MaGe Linux Operations
MaGe Linux Operations
Aug 12, 2022 · Fundamentals

Why Go Pointers Trip You Up: Common Pitfalls and Deep Dive

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.

closuresfor-rangememory escape
0 likes · 13 min read
Why Go Pointers Trip You Up: Common Pitfalls and Deep Dive
ByteFE
ByteFE
Aug 5, 2022 · Frontend Development

Curated Technical Reads: V8 Memory Management, Web3 DApp, Vue3 Compilation, DNS Query, JavaScript Runtime, Software Engineering, Design Patterns, Low‑Code Component Loading, TypeScript Advanced Types, React Security Practices

This collection highlights recent technical articles covering JavaScript engine memory management, building a Web3 decentralized app, Vue 3 compilation improvements, DNS query mechanisms, creating a custom JavaScript runtime, software engineering insights, singleton design pattern, low‑code remote component loading, advanced TypeScript types, and React security best practices.

BlockchainJavaScriptSecurity
0 likes · 5 min read
Curated Technical Reads: V8 Memory Management, Web3 DApp, Vue3 Compilation, DNS Query, JavaScript Runtime, Software Engineering, Design Patterns, Low‑Code Component Loading, TypeScript Advanced Types, React Security Practices
Dada Group Technology
Dada Group Technology
Jul 29, 2022 · Mobile Development

Network AOP Approaches for iOS Apps: Comparison and Implementation in Dada Express

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.

AFNetworkingMoyaNSURLProtocol
0 likes · 11 min read
Network AOP Approaches for iOS Apps: Comparison and Implementation in Dada Express
Yiche Technology
Yiche Technology
Jul 18, 2022 · Fundamentals

Deep Dive into Go's Map Implementation: Hash Tables, Hash Functions, and Runtime Mechanics

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.

Data StructuresGoHash Table
0 likes · 21 min read
Deep Dive into Go's Map Implementation: Hash Tables, Hash Functions, and Runtime Mechanics
ByteFE
ByteFE
Jul 15, 2022 · Frontend Development

Tech Newsletter: Highlights on Bun Runtime, ESM Loader Hooks, Canvas, Proxy/Reflect, Unit Testing, and More

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.

JavaScriptPerformanceServerless
0 likes · 7 min read
Tech Newsletter: Highlights on Bun Runtime, ESM Loader Hooks, Canvas, Proxy/Reflect, Unit Testing, and More
JavaScript
JavaScript
Jul 13, 2022 · Backend Development

Why Is Bun Gaining 24k Stars? Exploring the New JavaScript Runtime

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.

BunJavaScriptNode.js
0 likes · 3 min read
Why Is Bun Gaining 24k Stars? Exploring the New JavaScript Runtime
Tencent Cloud Developer
Tencent Cloud Developer
Jul 12, 2022 · Fundamentals

Understanding Go's Automatic Memory Management and Garbage Collection (Based on TCMalloc)

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.

Garbage CollectionGoMemory Management
0 likes · 21 min read
Understanding Go's Automatic Memory Management and Garbage Collection (Based on TCMalloc)
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Jul 6, 2022 · Backend Development

How to Let Go Programs Profile Themselves Automatically

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.

GoPerformance Monitoringautomatic sampling
0 likes · 12 min read
How to Let Go Programs Profile Themselves Automatically
Sohu Tech Products
Sohu Tech Products
Jun 30, 2022 · Mobile Development

Understanding the Implementation of weak Pointers in the Objective‑C Runtime

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.

C++ templatesMemory ManagementObjective‑C
0 likes · 19 min read
Understanding the Implementation of weak Pointers in the Objective‑C Runtime
Tencent Cloud Developer
Tencent Cloud Developer
May 24, 2022 · Backend Development

Three Advanced Go Techniques: Minimal Runtime, JIT Compilation, and Bootstrap

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.

AssemblyBootstrapGo
0 likes · 21 min read
Three Advanced Go Techniques: Minimal Runtime, JIT Compilation, and Bootstrap
IT Services Circle
IT Services Circle
Apr 14, 2022 · Frontend Development

Understanding the ShadowRealm API: Isolated JavaScript Execution Environments

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.

IsolationJavaScriptSecurity
0 likes · 10 min read
Understanding the ShadowRealm API: Isolated JavaScript Execution Environments
Sohu Tech Products
Sohu Tech Products
Apr 13, 2022 · Backend Development

Understanding Go Memory Leaks and Using pprof for Profiling

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.

CgoGCGo
0 likes · 9 min read
Understanding Go Memory Leaks and Using pprof for Profiling
IT Services Circle
IT Services Circle
Apr 12, 2022 · Backend Development

Resolving .NET Runtime and SDK Installation Issues on Windows

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.

.NETInstallationSDK
0 likes · 6 min read
Resolving .NET Runtime and SDK Installation Issues on Windows
High Availability Architecture
High Availability Architecture
Mar 24, 2022 · Backend Development

Understanding Go's Goroutine Scheduling: Design Principles, GMP Model, and Optimizations

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.

GMP modelGoconcurrency
0 likes · 14 min read
Understanding Go's Goroutine Scheduling: Design Principles, GMP Model, and Optimizations
IT Services Circle
IT Services Circle
Mar 15, 2022 · Frontend Development

Understanding How JavaScript Works: From Interpreted vs. Compiled Languages to the V8 Engine Execution Process

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.

EngineJITJavaScript
0 likes · 13 min read
Understanding How JavaScript Works: From Interpreted vs. Compiled Languages to the V8 Engine Execution Process
Tencent Cloud Developer
Tencent Cloud Developer
Feb 24, 2022 · Fundamentals

Understanding Property Registration and Runtime Access in a C++ Reflection Framework

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.

C++PropertyTemplate Metaprogramming
0 likes · 16 min read
Understanding Property Registration and Runtime Access in a C++ Reflection Framework
Tencent Cloud Developer
Tencent Cloud Developer
Feb 22, 2022 · Fundamentals

C++ Runtime Reflection Implementation Overview with Code Examples

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.

C++MetaprogrammingPonder
0 likes · 29 min read
C++ Runtime Reflection Implementation Overview with Code Examples
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 28, 2021 · Fundamentals

Mastering Java Reflection: What It Is, How It Works, and Real-World Uses

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.

Code ExampleJavaframework
0 likes · 8 min read
Mastering Java Reflection: What It Is, How It Works, and Real-World Uses
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Dec 24, 2021 · Fundamentals

Evolution of Garbage Collection in Go: From Mark‑Sweep to Hybrid Write Barriers

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.

Garbage CollectionGoMark-and-Sweep
0 likes · 31 min read
Evolution of Garbage Collection in Go: From Mark‑Sweep to Hybrid Write Barriers
Sohu Tech Products
Sohu Tech Products
Nov 17, 2021 · Mobile Development

KVO Mechanism Analysis for iOS Development

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.

KVOKey-Value ObservingObjective‑C
0 likes · 19 min read
KVO Mechanism Analysis for iOS Development
Youku Technology
Youku Technology
Nov 4, 2021 · Frontend Development

Can Visual Page Builders Turn Front‑End Development into a Low‑Code Powerhouse?

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.

Component ArchitectureDSLfrontend
0 likes · 15 min read
Can Visual Page Builders Turn Front‑End Development into a Low‑Code Powerhouse?
Coolpad Technology Team
Coolpad Technology Team
Oct 26, 2021 · Mobile Development

Understanding ART Garbage Collection in Android: Fundamentals, Mechanisms, and Performance Optimizations

This article introduces the fundamentals of Android Runtime (ART) garbage collection, covering its historical background, key milestones, core features such as RegionTLAB, read barriers, pause behavior, generational support, target heap size calculations, multiplier impact, GC trigger thresholds, Systrace analysis, and parameter tuning strategies.

ARTAndroidGarbage Collection
0 likes · 23 min read
Understanding ART Garbage Collection in Android: Fundamentals, Mechanisms, and Performance Optimizations
Tencent Cloud Developer
Tencent Cloud Developer
Aug 4, 2021 · Fundamentals

Golang Garbage Collection: Algorithms, Memory Management, and Evolution

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.

Concurrent MarkingGarbage CollectionGo
0 likes · 30 min read
Golang Garbage Collection: Algorithms, Memory Management, and Evolution
TiPaiPai Technical Team
TiPaiPai Technical Team
Jun 11, 2021 · Fundamentals

What Happens Inside Go’s Empty Interface? A Deep Dive into Memory Layout

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.

Goempty interfacememory layout
0 likes · 11 min read
What Happens Inside Go’s Empty Interface? A Deep Dive into Memory Layout
Sohu Tech Products
Sohu Tech Products
Jun 2, 2021 · Mobile Development

In‑Depth Analysis of YYModel Source Code and Its JSON Parsing Mechanism

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.

Objective‑CYYModeliOS
0 likes · 12 min read
In‑Depth Analysis of YYModel Source Code and Its JSON Parsing Mechanism
Alibaba Terminal Technology
Alibaba Terminal Technology
May 28, 2021 · Frontend Development

How Visual Page Builders Revolutionize Frontend Development with Logic Orchestration

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.

Component ArchitectureDSLlogic orchestration
0 likes · 15 min read
How Visual Page Builders Revolutionize Frontend Development with Logic Orchestration
AntTech
AntTech
May 26, 2021 · Cloud Native

Ant Group's Service Mesh Exploration and Cloud‑Native Application Runtime

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.

APIMOSNService Mesh
0 likes · 14 min read
Ant Group's Service Mesh Exploration and Cloud‑Native Application Runtime
ByteFE
ByteFE
May 25, 2021 · Frontend Development

Deep Dive into Webpack Runtime: Chunk, Runtime Modules, and Build Process

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.

Build ProcessChunkfrontend
0 likes · 21 min read
Deep Dive into Webpack Runtime: Chunk, Runtime Modules, and Build Process
Kuaishou Tech
Kuaishou Tech
May 21, 2021 · Mobile Development

Swift and Objective‑C Interoperability: Mixing, Modules, and Runtime Dynamics

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.

CocoaPodsModulesObjective‑C
0 likes · 25 min read
Swift and Objective‑C Interoperability: Mixing, Modules, and Runtime Dynamics
58 Tech
58 Tech
May 19, 2021 · Mobile Development

Hooking Swift Functions by Modifying the Virtual Table (VTable)

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.

HookingSwiftTypeContext
0 likes · 19 min read
Hooking Swift Functions by Modifying the Virtual Table (VTable)
Senior Brother's Insights
Senior Brother's Insights
May 5, 2021 · Fundamentals

What Is the True Maximum Length of a Java String?

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.

JVMJavaLength Limit
0 likes · 8 min read
What Is the True Maximum Length of a Java String?
iQIYI Technical Product Team
iQIYI Technical Product Team
Apr 23, 2021 · Cloud Native

iQIYI Container Practice – Cloud‑Native Deployment Exploration and Implementation

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.

KubernetesNetworkingcontainer
0 likes · 15 min read
iQIYI Container Practice – Cloud‑Native Deployment Exploration and Implementation
JD Retail Technology
JD Retail Technology
Apr 19, 2021 · Fundamentals

Understanding the Objective‑C Class Loading Process in dyld and the objc Runtime

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.

Class LoadingObjective‑Cdyld
0 likes · 19 min read
Understanding the Objective‑C Class Loading Process in dyld and the objc Runtime
Alibaba Terminal Technology
Alibaba Terminal Technology
Apr 9, 2021 · Frontend Development

Master Babel 7: Resolve Common Runtime Errors and Optimize Polyfills

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.

BabelPolyfillcore-js
0 likes · 14 min read
Master Babel 7: Resolve Common Runtime Errors and Optimize Polyfills
DeWu Technology
DeWu Technology
Apr 2, 2021 · Fundamentals

How Android’s ART Runtime Manages Heap Memory: A Deep Dive into GC Structures

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.

ARTAndroidGarbage Collection
0 likes · 43 min read
How Android’s ART Runtime Manages Heap Memory: A Deep Dive into GC Structures
Sohu Tech Products
Sohu Tech Products
Mar 31, 2021 · Frontend Development

Front‑End Performance Optimization: Loading‑Time and Runtime Techniques

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.

JavaScriptOptimizationWeb
0 likes · 24 min read
Front‑End Performance Optimization: Loading‑Time and Runtime Techniques
58 Tech
58 Tech
Mar 19, 2021 · Mobile Development

Design and Implementation of Taro 3 Adaptation for React Native

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.

MetroTaROmobile development
0 likes · 14 min read
Design and Implementation of Taro 3 Adaptation for React Native
ITPUB
ITPUB
Jan 14, 2021 · Fundamentals

Uncovering Swift’s Binary Layout: From Dynamic Calls to Mach‑O Class Structures

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.

Dynamic InvocationMach-OObjective‑C
0 likes · 16 min read
Uncovering Swift’s Binary Layout: From Dynamic Calls to Mach‑O Class Structures
58 Tech
58 Tech
Jan 13, 2021 · Fundamentals

Exploring Swift Binary Structure and Dynamic Method Invocation in Mach-O

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.

Dynamic InvocationMach-OSwift
0 likes · 16 min read
Exploring Swift Binary Structure and Dynamic Method Invocation in Mach-O
Programmer DD
Programmer DD
Dec 24, 2020 · Fundamentals

How to Retrieve Generic Types at Runtime with Gson’s TypeToken

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.

GsonJavaTypeToken
0 likes · 7 min read
How to Retrieve Generic Types at Runtime with Gson’s TypeToken
Taobao Frontend Technology
Taobao Frontend Technology
Dec 21, 2020 · Frontend Development

How Rax Enables Runtime Rendering for Mini‑Programs: Architecture and Optimizations

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.

KbonePerformanceRax
0 likes · 15 min read
How Rax Enables Runtime Rendering for Mini‑Programs: Architecture and Optimizations
GrowingIO Tech Team
GrowingIO Tech Team
Nov 26, 2020 · Mobile Development

Mastering iOS AOP: From Method Swizzling to Fishhook and Beyond

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.

AOPMethod SwizzlingObjective‑C
0 likes · 21 min read
Mastering iOS AOP: From Method Swizzling to Fishhook and Beyond
Tongcheng Travel Technology Center
Tongcheng Travel Technology Center
Nov 24, 2020 · Frontend Development

Thanos Multi‑Platform Development Framework: Architecture, Components, and Implementation

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.

Mini ProgramVuecompiler
0 likes · 15 min read
Thanos Multi‑Platform Development Framework: Architecture, Components, and Implementation
Programmer DD
Programmer DD
Oct 23, 2020 · Backend Development

Node.js 15 Released: npm7 Support, Throw Mode, and New Runtime Features

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.

JavaScriptNode.jsnpm
0 likes · 3 min read
Node.js 15 Released: npm7 Support, Throw Mode, and New Runtime Features
JD Retail Technology
JD Retail Technology
Oct 20, 2020 · Fundamentals

Understanding the Object Creation Process in Objective‑C

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.

Object CreationObjective‑Calloc
0 likes · 11 min read
Understanding the Object Creation Process in Objective‑C
Java Captain
Java Captain
Sep 7, 2020 · Fundamentals

Understanding the Java JVM Memory Model and Its Partitions

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.

JVMJavaMemory Model
0 likes · 4 min read
Understanding the Java JVM Memory Model and Its Partitions
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 16, 2020 · Mobile Development

Boost iOS AOP Performance: Inside Alibaba’s Lokie Framework

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.

AOPC++Performance
0 likes · 15 min read
Boost iOS AOP Performance: Inside Alibaba’s Lokie Framework
Beike Product & Technology
Beike Product & Technology
Jul 16, 2020 · Fundamentals

In-depth Source Analysis of Go Channels (Go 1.14)

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.

BufferGochannel
0 likes · 14 min read
In-depth Source Analysis of Go Channels (Go 1.14)