BestHub
Sign in
Tagged articles
228 articles
Page 2 of 3
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.

Cloud NativeDebuggingNode.js
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.

DockerRuntimeWasmEdge
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.

Cloud NativeDebuggingNode.js
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.

GoroutineRuntimeScheduler
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.

BackendJITPyston
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.

DuktapeEmbeddingJavaScript
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.

BackendBunJavaScript
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.

Runtimeclosuresfor-range
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.

BlockchainJavaScriptRuntime
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 StructuresGoInitialization
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.

JavaScriptRuntimeServerless
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 MonitoringProfiling
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.

IsolationJavaScriptRuntime
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.

GoProfilingRuntime
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.

InstallationRuntimeSDK
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 modelGoGoroutine
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++PropertyRuntime
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++FrameworkPonder
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 ExampleFrameworkJava
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 ObservingMobile Development
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 ArchitectureDSLRuntime
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
Cloud Native Technology Community
Cloud Native Technology Community
Aug 12, 2021 · Industry Insights

What 2021 Container Security Trends Reveal About Runtime Risks and Tool Adoption

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.

Cloud NativeContainer SecurityDevOps
0 likes · 13 min read
What 2021 Container Security Trends Reveal About Runtime Risks and Tool Adoption
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
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.

JSONObjective‑CRuntime
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 ArchitectureDSLRuntime
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.

APIMOSNMicroservices
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 ProcessChunkRuntime
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.

CocoaPodsInteroperabilityModules
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.

HookingRuntimeSwift
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.

Compile-timeJVMJava
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.

ContainerKubernetesNetworking
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.

Objective‑CRuntimeclass loading
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.

PolyfillRuntimebabel
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.

JavaScriptRuntimeWeb
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.

MetroMobile DevelopmentReact Native
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-ORuntime
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.

GenericsGsonJava
0 likes · 7 min read
How to Retrieve Generic Types at Runtime with Gson’s TypeToken
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.

Method SwizzlingMobile DevelopmentObjective‑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.

FrameworkMini ProgramRuntime
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.jsRuntime
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‑CRuntime
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.

CRuntimeaop
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.

ChannelGoGoroutine
0 likes · 14 min read
In-depth Source Analysis of Go Channels (Go 1.14)
Programmer DD
Programmer DD
Jul 8, 2020 · Fundamentals

Unlock Java’s Power: Master Reflection for Dynamic Code

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.

ClassReflectionRuntime
0 likes · 16 min read
Unlock Java’s Power: Master Reflection for Dynamic Code
JD Retail Technology
JD Retail Technology
Jun 28, 2020 · Mobile Development

Understanding iOS Runtime: Dictionary-to-Object Conversion, Associated Objects, and Method Swizzling

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
0 likes · 7 min read
Understanding iOS Runtime: Dictionary-to-Object Conversion, Associated Objects, and Method Swizzling
Meituan Technology Team
Meituan Technology Team
Jun 24, 2020 · Mobile Development

Dynamic Flutter Architecture and Flap System for Mobile App 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.

Code GenerationDSLDynamic Update
0 likes · 35 min read
Dynamic Flutter Architecture and Flap System for Mobile App Development
JD Retail Technology
JD Retail Technology
Jun 23, 2020 · Mobile Development

Understanding and Implementing Key-Value Observing (KVO) in iOS

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.

KVOMobile DevelopmentObjective‑C
0 likes · 7 min read
Understanding and Implementing Key-Value Observing (KVO) in iOS
JD Retail Technology
JD Retail Technology
May 21, 2020 · Mobile Development

Understanding the Sunglasses Crash Investigation Tool and Objective‑C Runtime Mechanisms

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.

Crash HandlingMethod SwizzlingMobile Development
0 likes · 14 min read
Understanding the Sunglasses Crash Investigation Tool and Objective‑C Runtime Mechanisms
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Mar 27, 2020 · Operations

Unlock Faster Android Apps: How Dex2OAT Compiles and Optimizes Your Code

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.

AOT compilationAndroidPerformance Optimization
0 likes · 9 min read
Unlock Faster Android Apps: How Dex2OAT Compiles and Optimizes Your Code
Senior Brother's Insights
Senior Brother's Insights
Mar 25, 2020 · Backend Development

Master Java Reflection: From Basics to Advanced Usage

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.

APIClassJava
0 likes · 10 min read
Master Java Reflection: From Basics to Advanced Usage
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Dec 20, 2019 · Fundamentals

Understanding Duck Typing and Interface Implementation in Go

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.

GoInterfaceRuntime
0 likes · 22 min read
Understanding Duck Typing and Interface Implementation in Go
Programmer DD
Programmer DD
Dec 20, 2019 · Backend Development

Mastering Java Annotations: From Basics to Custom AOP Integration

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.

Compile-timeJavaRuntime
0 likes · 8 min read
Mastering Java Annotations: From Basics to Custom AOP Integration
Sohu Tech Products
Sohu Tech Products
Dec 18, 2019 · Mobile Development

Understanding Objective‑C Object Memory Layout and Alignment

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.

Objective‑CRuntimeiOS
0 likes · 22 min read
Understanding Objective‑C Object Memory Layout and Alignment
21CTO
21CTO
Dec 7, 2019 · Fundamentals

Why WebAssembly Is the Fourth Web Language and How It Boosts Performance

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.

BinaryRuntimeWasm
0 likes · 7 min read
Why WebAssembly Is the Fourth Web Language and How It Boosts Performance