BestHub
Sign in
Tagged articles
228 articles
Page 1 of 3
21CTO
21CTO
May 16, 2026 · Fundamentals

What’s New in JDK 26? Key Language, Library, and Runtime Enhancements

JDK 26, the latest non‑LTS Java release, adds ten JEP‑driven enhancements—including pattern‑matching for instanceof and switch, HTTP/3 support, PEM encoding, structured concurrency, lazy constants, a vector API, Applet removal, final‑mean changes, AOT cache support, and G1 GC throughput gains—providing developers with practical new capabilities to test before the next LTS version.

JEPJavaLanguage
0 likes · 8 min read
What’s New in JDK 26? Key Language, Library, and Runtime Enhancements
Architect
Architect
May 2, 2026 · Backend Development

From a 30‑Minute DIY Agent to Harness as the New Backend – What Gaps Remain for an Agent‑Ready System?

The article examines a minimal 30‑minute Agent loop demo, then analyzes how Harness can serve as the backend by introducing a runtime capability registry, worker lifecycle management, diverse triggers, and unified tracing, outlining four concrete design actions to close the gaps for agent‑ready systems.

AgentBackend ArchitectureCapability Registry
0 likes · 18 min read
From a 30‑Minute DIY Agent to Harness as the New Backend – What Gaps Remain for an Agent‑Ready System?
Full-Stack Cultivation Path
Full-Stack Cultivation Path
Mar 25, 2026 · Artificial Intelligence

Understanding Tool Use in LLMs: How Models Leverage Tool Calls

This article explains why large language models need tool use, defines the concepts of Tool Use, Tool Call, and Function Calling, compares them, walks through a complete tool‑use workflow, and discusses architectural, safety, and design considerations for building reliable LLM agents.

AgentLLMPrompt engineering
0 likes · 17 min read
Understanding Tool Use in LLMs: How Models Leverage Tool Calls
java1234
java1234
Feb 10, 2026 · Fundamentals

Understanding Java Reflection: Core Concepts, Use Cases, and Trade‑offs

This article explains Java's reflection mechanism, covering its main uses such as dynamic class loading, handling unknown types, accessing private members, and framework development, then walks through basic steps, a complete code example, and discusses its advantages and drawbacks.

Dynamic LoadingJavaReflection
0 likes · 6 min read
Understanding Java Reflection: Core Concepts, Use Cases, and Trade‑offs
21CTO
21CTO
Jan 16, 2026 · Backend Development

What’s New in PHP 8.5? Pipe Operators, PFA, and Upcoming Features Explained

The article reviews PHP 8.5’s late‑2025 release, highlighting enhanced pipe operators, partial function application (PFA), object‑cloning syntax, closure improvements, richer fatal‑error stack traces, and upcoming RFCs such as pattern matching, while also covering related runtimes like FrankenPHP, the Mago toolchain, TrueAsync, and the PHPverse conference.

AsyncPHPRuntime
0 likes · 8 min read
What’s New in PHP 8.5? Pipe Operators, PFA, and Upcoming Features Explained
Java One
Java One
Dec 26, 2025 · Fundamentals

How C/C++, Java, and Python Run: A Deep Dive into Compilation and Execution

This article compares the execution models of C/C++, Java, and Python, explaining how compiled machine code, bytecode with JVM, and interpreted bytecode with the Python virtual machine operate, and illustrates each process with example file structures and compilation steps.

CCompilationExecution Model
0 likes · 6 min read
How C/C++, Java, and Python Run: A Deep Dive into Compilation and Execution
IT Services Circle
IT Services Circle
Dec 22, 2025 · Fundamentals

How Go’s Runtime Manages Memory: From Kernel SLAB to mheap and mcache

This article explains Go's memory allocator by comparing it with the Linux kernel SLAB allocator, detailing the page‑heap (mheap), span structures, per‑P caches (mcache), and the mallocgc path for small and large allocations, while showing key source code snippets and diagrams.

GoMemory ManagementRuntime
0 likes · 18 min read
How Go’s Runtime Manages Memory: From Kernel SLAB to mheap and mcache
IT Services Circle
IT Services Circle
Oct 9, 2025 · Backend Development

Why Modern JavaScript Runtimes Matter: Bun, Deno, and Edge in 2024

This guide explains how newer JavaScript runtimes like Bun, Deno, and edge platforms reshape development speed, security, and global performance, offering code examples, benchmark comparisons, and practical advice for choosing the right runtime for your projects.

BunDenoEdge Computing
0 likes · 7 min read
Why Modern JavaScript Runtimes Matter: Bun, Deno, and Edge in 2024
Java Tech Enthusiast
Java Tech Enthusiast
Oct 5, 2025 · Backend Development

Why Go Needs Goroutine IDs: A Proposal to Enhance Runtime Profiling

This article explains a Go proposal to add unique Goroutine identifiers and start program counters to the runtime profiling API, detailing the background problem, example code, the suggested API changes, community discussion, and the practical impact on performance analysis.

GoroutineRuntimegoid
0 likes · 9 min read
Why Go Needs Goroutine IDs: A Proposal to Enhance Runtime Profiling
Alibaba Cloud Native
Alibaba Cloud Native
Sep 19, 2025 · Cloud Native

Why Serverless Is the Future of AI Apps: From Stateless to Session‑Aware Cloud‑Native Architecture

The article examines how AI application infrastructure is shifting from traditional always‑on, stateless deployments to serverless models that balance cost, scalability, and stateful conversational needs, outlining architectural challenges, evolution stages, and emerging solutions such as external state storage, session‑affinity scheduling, durable functions, and session‑oriented runtimes.

AIRuntimeServerless
0 likes · 26 min read
Why Serverless Is the Future of AI Apps: From Stateless to Session‑Aware Cloud‑Native Architecture
Raymond Ops
Raymond Ops
Sep 13, 2025 · Cloud Native

Why Choose containerd Over Docker? A Deep Dive into Kubernetes Runtime

This article explains how Docker relies on Linux kernel features to isolate processes, introduces containerd as an industrial‑grade container runtime, compares their logging, configuration, CNI handling, and command interfaces, and provides practical tables and examples for migrating from Docker to containerd in Kubernetes environments.

CNIRuntimecontainerd
0 likes · 10 min read
Why Choose containerd Over Docker? A Deep Dive into Kubernetes Runtime
Alibaba Cloud Native
Alibaba Cloud Native
Sep 5, 2025 · Artificial Intelligence

Why Today's Cloud‑Native Runtimes Fail AI Agents and How a New Serverless Architecture Can Fix It

The article argues that the rapid rise of LLM‑driven AI agents exposes fundamental mismatches in current cloud‑native runtimes such as Kubernetes, and proposes an AI‑native serverless evolution that delivers lightweight session management, secure sandboxes, extreme elasticity, and cost‑effective on‑demand execution.

AIFunction ComputingRuntime
0 likes · 32 min read
Why Today's Cloud‑Native Runtimes Fail AI Agents and How a New Serverless Architecture Can Fix It
IT Services Circle
IT Services Circle
Aug 24, 2025 · Backend Development

What’s New in Go 1.25? Key Toolchain, Runtime, and Library Enhancements

Go 1.25, released in August 2025, brings a suite of toolchain, runtime, and standard‑library upgrades—including default memory‑leak detection, a new go.mod ignore directive, container‑aware GOMAXPROCS, experimental greentea GC, JSON V2, and several new diagnostics—without changing the language syntax.

ContainerGoGo 1.25
0 likes · 8 min read
What’s New in Go 1.25? Key Toolchain, Runtime, and Library Enhancements
Liangxu Linux
Liangxu Linux
Jul 10, 2025 · Fundamentals

When to Use const vs constexpr in C++? A Practical Guide

This article explains the differences between C++ const and constexpr, using a kettle analogy, detailed code examples, and practical guidelines to help developers choose the right keyword for compile‑time or runtime constants, improve performance, and write safer code.

C++Compile-timeConstants
0 likes · 8 min read
When to Use const vs constexpr in C++? A Practical Guide
php Courses
php Courses
Jun 19, 2025 · Backend Development

Unlock Go’s High‑Performance Secrets: Scheduler, GC, and Memory Model Explained

This article delves into Go’s runtime, explaining the Goroutine scheduler’s G‑P‑M model and work‑stealing, the concurrent tri‑color garbage collector with its phases and tuning flags, the memory allocation hierarchy and escape analysis, and practical tips for high‑performance Go applications.

Garbage CollectionGoMemory Model
0 likes · 6 min read
Unlock Go’s High‑Performance Secrets: Scheduler, GC, and Memory Model Explained
BirdNest Tech Talk
BirdNest Tech Talk
Jun 13, 2025 · Cloud Native

Go 1.25 Deep Dive: Performance Boosts, New Tools, and Cloud‑Native Features

Go 1.25 introduces an experimental greenteagc garbage collector, container‑aware GOMAXPROCS, enhanced go vet analyzers, new go.mod ignore directive, work package mode, expanded standard library (including testing/synctest and experimental JSON v2), platform updates, and security hardening, all aimed at higher performance, developer productivity, and cloud‑native readiness.

Cloud NativeGoRuntime
0 likes · 26 min read
Go 1.25 Deep Dive: Performance Boosts, New Tools, and Cloud‑Native Features
IT Services Circle
IT Services Circle
Jun 5, 2025 · Backend Development

Can Go Run Without an OS? Exploring the New Bare‑Metal Support Proposal

This article examines the recent Go proposal to add a GOOS=none target, enabling Go programs to run on bare‑metal hardware without an operating system, outlines the TamaGo project's achievements, discusses compatibility challenges, and evaluates the potential impact on Go’s future development and use cases.

Bare MetalGoRuntime
0 likes · 7 min read
Can Go Run Without an OS? Exploring the New Bare‑Metal Support Proposal
Java One
Java One
May 4, 2025 · Fundamentals

How Does Java Execution Differ from C? A 3‑Minute JVM Deep Dive

This article compares the compilation and runtime processes of C and Java programs, explains Java's class loading, linking, initialization, memory layout, execution engine components, and native interface, and highlights why Java startup is slower than native C execution.

CompilationJVMJava
0 likes · 16 min read
How Does Java Execution Differ from C? A 3‑Minute JVM Deep Dive
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
May 1, 2025 · Frontend Development

Comprehensive Overview of Modern Frontend Development Frameworks, Tools, and Ecosystems

This article provides a detailed comparison of current frontend frameworks, styling solutions, build tools, package managers, state‑management libraries, JavaScript runtimes, and cross‑platform development options, highlighting their origins, key features, official sites, GitHub statistics, and practical trade‑offs for developers.

RuntimeStylingbuild tools
0 likes · 17 min read
Comprehensive Overview of Modern Frontend Development Frameworks, Tools, and Ecosystems
JD Tech Talk
JD Tech Talk
Apr 29, 2025 · Backend Development

Understanding Java ShutdownHook: Principles, Implementation, and Use Cases

This article explains the concept of Java's Runtime.addShutdownHook, details its underlying implementation in the Runtime and ApplicationShutdownHooks classes, demonstrates usage with code examples, discusses typical application scenarios, potential risks of long‑running hooks, and provides best‑practice recommendations for safe JVM shutdown handling.

JVMJavaResource Management
0 likes · 7 min read
Understanding Java ShutdownHook: Principles, Implementation, and Use Cases
Infra Learning Club
Infra Learning Club
Apr 27, 2025 · Cloud Native

Why Containerd 2.x Fails to Find nvidia‑smi with GPU‑Operator and How to Fix It

When deploying a Kubernetes cluster with kubespray and the NVIDIA runtime, Containerd 2.x reports "nvidia‑smi not found" because the go‑toml v2 parser treats the "binaryName" key differently, causing the wrong runtime wrapper to be used; the article details the configuration inspection, version comparison, code demonstrations, and practical work‑arounds.

Runtimecontainerdgo-toml
0 likes · 8 min read
Why Containerd 2.x Fails to Find nvidia‑smi with GPU‑Operator and How to Fix It
FunTester
FunTester
Mar 5, 2025 · Backend Development

Calling Third‑Party Java Methods with Byteman in Chaos Mesh

This article demonstrates how to use Byteman’s DO execution module on the Chaos Mesh platform to invoke static or instance methods of external Java classes without modifying the original code, covering reflection, ClassLoader tricks, and a complete BTM rule example.

BytemanChaos MeshFault Injection
0 likes · 7 min read
Calling Third‑Party Java Methods with Byteman in Chaos Mesh
Radish, Keep Going!
Radish, Keep Going!
Feb 20, 2025 · Backend Development

Why Go Replaces runtime.SetFinalizer with runtime.AddCleanup and How to Use It

This article explains that Go plans to deprecate runtime.SetFinalizer in favor of the newer runtime.AddCleanup, demonstrates how to use SetFinalizer for resource cleanup before garbage collection, highlights common pitfalls such as extended lifetimes and memory leaks, and shows real‑world examples from the standard library and go‑cache.

AddCleanupGarbage CollectionGo
0 likes · 6 min read
Why Go Replaces runtime.SetFinalizer with runtime.AddCleanup and How to Use It
Radish, Keep Going!
Radish, Keep Going!
Feb 11, 2025 · Fundamentals

How Go 1.24’s New Spinning Mutex Boosts Performance by Up to 70%

The article explains the background of the Go mutex performance proposal, details the new spinning flag added to the mutex state, walks through fast‑path, spinning, and sleep phases of lock acquisition, presents benchmark results showing up to 70% speed‑up, and provides references for further reading.

GoRuntimeconcurrency
0 likes · 11 min read
How Go 1.24’s New Spinning Mutex Boosts Performance by Up to 70%
Kuaishou Frontend Engineering
Kuaishou Frontend Engineering
Dec 26, 2024 · Frontend Development

Automating Multi‑Format Sequence‑Frame Conversion for Web Animations

This article explains how a motion‑effects platform decouples design and development by automatically converting sequence‑frame animations into multiple formats (APNG, WEBP, AVIF, video), provides a runtime that dynamically selects the optimal format, and offers batch conversion APIs to improve performance and reduce engineering overhead.

RuntimeWeb Performanceanimation
0 likes · 14 min read
Automating Multi‑Format Sequence‑Frame Conversion for Web Animations
BirdNest Tech Talk
BirdNest Tech Talk
Dec 6, 2024 · Backend Development

Go vs Rust Concurrency: Stackful vs Stackless Coroutines and Memory Impact

The article compares Go’s stackful, green‑thread model with Rust’s stackless, future‑based approach, explaining how each runtime schedules tasks, the memory overhead of goroutine stacks (2 KiB minimum in Go 1.22), the challenges of async‑await integration, and why Rust’s performance gains come with a fragmented ecosystem.

AsyncCoroutinesGo
0 likes · 8 min read
Go vs Rust Concurrency: Stackful vs Stackless Coroutines and Memory Impact
Kuaishou Frontend Engineering
Kuaishou Frontend Engineering
Dec 4, 2024 · Frontend Development

How Vision Powers Kuaishou’s Large‑Scale Animation: Architecture, Challenges, and Solutions

This article details the Vision animation platform that underpins Kuaishou’s large‑scale online events, covering its overall architecture, core value, existing production and delivery challenges, evolution roadmap, key runtime and format‑conversion features, as well as dynamic replacement and code‑generation capabilities.

Code GenerationPerformance TestingRuntime
0 likes · 16 min read
How Vision Powers Kuaishou’s Large‑Scale Animation: Architecture, Challenges, and Solutions
IT Services Circle
IT Services Circle
Nov 19, 2024 · Backend Development

New Features in Recent Node.js Releases (v20–v23)

The article reviews the rapid evolution of Node.js, detailing new security, testing, module, environment, and runtime capabilities introduced from version 20 through 23, while also noting the emergence of competing runtimes Deno and Bun and their impact on the JavaScript ecosystem.

BunDenoJavaScript
0 likes · 9 min read
New Features in Recent Node.js Releases (v20–v23)
Java Architecture Stack
Java Architecture Stack
Nov 18, 2024 · Fundamentals

Inside Go’s Runtime: How mcache and mheap Manage Memory

This article provides a detailed technical analysis of Go's runtime memory management, covering the initialization of the mheap structure, small‑object allocation via mcache, large‑object handling, the three‑color mark‑and‑sweep garbage collector, memory release mechanisms, and the optimization techniques that coordinate mcache and mheap for efficient concurrent execution.

Garbage CollectionGoMemory Management
0 likes · 12 min read
Inside Go’s Runtime: How mcache and mheap Manage Memory
Satori Komeiji's Programming Classroom
Satori Komeiji's Programming Classroom
Nov 7, 2024 · Fundamentals

How Does Python’s VM Implement and Throw Exceptions?

The article dissects Python’s exception mechanism, showing how the interpreter and virtual machine raise, record, and propagate errors via thread‑state objects, traceback chains, and C‑level APIs, while also illustrating generator return values, Java checked exceptions, and the final printing of tracebacks.

C APIException HandlingRuntime
0 likes · 16 min read
How Does Python’s VM Implement and Throw Exceptions?
Python Programming Learning Circle
Python Programming Learning Circle
Nov 2, 2024 · Fundamentals

Common Python Errors and How to Fix Them

This article presents 17 frequent Python runtime and syntax errors, explains why they occur, and provides clear code examples and corrections to help beginners quickly identify and resolve these issues while improving their debugging skills.

DebuggingPythonRuntime
0 likes · 10 min read
Common Python Errors and How to Fix Them
BirdNest Tech Talk
BirdNest Tech Talk
Oct 20, 2024 · Fundamentals

Unveiling Go’s runq: Lock‑Free Queues Behind the Scheduler

This article dissects Go's runtime GPM model and the lock‑free runq data structure, detailing its fields, core operations such as runqput, runqget, runqgrab, and their atomic implementations, while also comparing local and global queues and illustrating the code paths with concrete examples.

Data StructuresGoRuntime
0 likes · 24 min read
Unveiling Go’s runq: Lock‑Free Queues Behind the Scheduler
21CTO
21CTO
Oct 13, 2024 · Backend Development

What’s New in Deno 2.0? A Deep Dive into Its Node.js Compatibility and Updated Standard Library

Deno 2.0, the latest production release of the open‑source Deno runtime, brings major updates for JavaScript, TypeScript and WebAssembly, offers full backward compatibility with Node.js and npm, stabilizes its standard library, introduces private NPM registry support, workspace/monorepo features, and adds enhanced formatting, linting, and coverage tools.

DenoJavaScriptNode.js compatibility
0 likes · 4 min read
What’s New in Deno 2.0? A Deep Dive into Its Node.js Compatibility and Updated Standard Library
DaTaobao Tech
DaTaobao Tech
Sep 6, 2024 · Backend Development

Go Language Coroutine Principles and GMP Model Implementation

The article examines Go's coroutine architecture and its GMP (Goroutine-Machine-Processor) model, tracing coroutine history, comparing kernel, user, and hybrid thread models, and detailing G, M, and P components, scheduling principles, work-stealing, preemption, and runtime implementation that give Go high concurrency and low latency.

CoroutinesGMP modelGo language
0 likes · 37 min read
Go Language Coroutine Principles and GMP Model Implementation
Infra Learning Club
Infra Learning Club
Aug 27, 2024 · Cloud Native

Kubelet Source Code Deep Dive: Understanding Its Core Workflows

The article dissects the kubelet architecture, detailing its main syncLoop control cycle, auxiliary loops, and key managers such as podManager, podWorkers, evictionManager, probeManager, and runtime components, while explaining how pod updates, PLEG mechanisms, and various channels coordinate pod lifecycle and resource handling.

Cloud NativeKubernetesRuntime
0 likes · 9 min read
Kubelet Source Code Deep Dive: Understanding Its Core Workflows
21CTO
21CTO
Jul 15, 2024 · Backend Development

Bridging Python and JavaScript: Inside the PythonMonkey Runtime

PythonMonkey is a SpiderMonkey‑based JavaScript runtime embedded in Python that lets developers run JavaScript inside Python and vice‑versa, offering WebAssembly support, a Node‑like PMJS environment, and a roadmap of cross‑language features aimed at speeding development and reducing maintenance overhead.

Cross-languageJavaScriptPythonMonkey
0 likes · 10 min read
Bridging Python and JavaScript: Inside the PythonMonkey Runtime
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 26, 2024 · Backend Development

JVM Class Loading Explained: From Loading to Initialization

This article provides a comprehensive, step‑by‑step explanation of the JVM class‑loading mechanism, covering the five phases—Loading, Verification, Preparation, Resolution, and Initialization—along with diagrams and detailed descriptions of each operation performed by the JVM.

Backend DevelopmentJVMJava
0 likes · 7 min read
JVM Class Loading Explained: From Loading to Initialization
Ops Development & AI Practice
Ops Development & AI Practice
May 21, 2024 · Fundamentals

Mastering Call Stacks and Stack Frames: A Deep Dive for Developers

Understanding how call stacks and stack frames work is essential for developers, and this article explains their dynamic, ordered, and local nature, details stack frame structure, walks through a Go code example illustrating function calls and returns, and shows how to leverage runtime utilities for debugging.

DebuggingGo languageRuntime
0 likes · 7 min read
Mastering Call Stacks and Stack Frames: A Deep Dive for Developers
DeWu Technology
DeWu Technology
Apr 15, 2024 · Mobile Development

Debugging Performance Degradation of Android 14 Debug Builds: Root Cause and Workarounds

The severe jank observed in Android 14 debug builds stems from the DEBUG_JAVA_DEBUGGABLE flag triggering DeoptimizeBootImage, which forces boot‑image methods onto the slow switch interpreter; a temporary hook clearing the flag and a permanent fix using UpdateEntrypointsForDebuggable restore performance, with Google planning an official fix in Android 15.

ARTAndroidDebugging
0 likes · 12 min read
Debugging Performance Degradation of Android 14 Debug Builds: Root Cause and Workarounds
21CTO
21CTO
Feb 28, 2024 · Backend Development

Deno 1.41 Cuts Binary Size by 50% and Adds Official Linux ARM64 Support

Version 1.41 of the Deno runtime, released on February 23, reduces compiled binary sizes by up to 50%, introduces official Linux ARM64 binaries, adds several Node.js compatibility fixes, expands API capabilities, and improves language server features, while outlining future plans for further size reductions and custom builds.

DenoLinux ARM64Node.js compatibility
0 likes · 4 min read
Deno 1.41 Cuts Binary Size by 50% and Adds Official Linux ARM64 Support
Amap Tech
Amap Tech
Feb 28, 2024 · Mobile Development

Deep Dive into Android ClassLoader and findLoadedClass Mechanism for Code Coverage

The article details a high‑performance, high‑stability Android code‑coverage technique that creates a surrogate ClassLoader, copies the target PathClassLoader’s private classTable pointer, and invokes findLoadedClass on this loader to query a class’s load state without triggering Android’s native optimization that would otherwise automatically load the class.

AndroidReflectionRuntime
0 likes · 13 min read
Deep Dive into Android ClassLoader and findLoadedClass Mechanism for Code Coverage
Tencent Music Tech Team
Tencent Music Tech Team
Dec 22, 2023 · Mobile Development

Root Cause Analysis of iOS Crash Caused by Method Swizzle on NSString

The app crashed on launch because a third‑party SDK swizzled NSString’s stringByAppendingString: with a method whose name conflicted with the app’s own swizzle, causing recursive calls through the __NSCFString class‑cluster and a stack overflow; renaming the methods with a unique prefix and excluding __NSCFString from swizzling resolves the issue.

Class ClusterMethod SwizzleObjective‑C
0 likes · 11 min read
Root Cause Analysis of iOS Crash Caused by Method Swizzle on NSString
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 20, 2023 · Backend Development

Using Javaassist for Bytecode Manipulation: Creating, Modifying, and Enhancing Java Classes

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.

Code GenerationJavaJavaassist
0 likes · 6 min read
Using Javaassist for Bytecode Manipulation: Creating, Modifying, and Enhancing Java Classes
HelloTech
HelloTech
Oct 17, 2023 · Frontend Development

Running React Code in Mini Programs with Taro: Compilation vs Runtime Approaches

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.

CompilationDOM SimulationMini Program
0 likes · 21 min read
Running React Code in Mini Programs with Taro: Compilation vs Runtime Approaches
Java Captain
Java Captain
Oct 7, 2023 · Fundamentals

Understanding the JVM Memory Model, Garbage Collection, and Memory Management Strategies

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.

Garbage CollectionJVMJava
0 likes · 6 min read
Understanding the JVM Memory Model, Garbage Collection, and Memory Management Strategies
JD Tech
JD Tech
Aug 31, 2023 · Fundamentals

Understanding JVM Runtime Memory Layout, Garbage Collection Roots, and Algorithms

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.

Garbage CollectionGenerational GCJVM
0 likes · 16 min read
Understanding JVM Runtime Memory Layout, Garbage Collection Roots, and Algorithms
FunTester
FunTester
Aug 17, 2023 · Backend Development

Understanding java.lang.Runtime.addShutdownHook for JVM Graceful Shutdown

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.

GroovyJavaRuntime
0 likes · 6 min read
Understanding java.lang.Runtime.addShutdownHook for JVM Graceful Shutdown
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.

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

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

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

EngineRuntimeWasmEdge
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-WASMRuntimeWasm
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‑PlatformRuntimeWasm
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 LanguageRuntimeStandard Library
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.

ChannelGoGoroutine
0 likes · 29 min read
Understanding Go Channels: Implementation, Usage, and Performance