BestHub
Sign in
Tagged articles
960 articles
Page 6 of 10
TAL Education Technology
TAL Education Technology
Jul 1, 2022 · Fundamentals

Why the JVM Can Run Cross‑Platform and an In‑Depth Look at Its Internal Architecture

This article explains how the Java Virtual Machine achieves write‑once‑run‑anywhere by abstracting platform differences, then details the JVM’s internal components—including the class‑loader subsystem, runtime data areas such as heap, stack, method area, and program counter—followed by code examples and analysis of object layout, pointer compression, and memory allocation strategies.

Garbage CollectionHeapJVM
0 likes · 30 min read
Why the JVM Can Run Cross‑Platform and an In‑Depth Look at Its Internal Architecture
Java Backend Technology
Java Backend Technology
Jul 1, 2022 · Big Data

How to Find the Most Frequent Age in a 10 GB File Using Java Multithreading

This article explains how to generate a 10 GB file of age data, read it efficiently on a machine with limited memory, and use both single‑threaded and multithreaded Java techniques—including a producer‑consumer model and divide‑and‑conquer—to identify the age that appears most frequently, while analyzing performance, memory usage, and CPU utilization.

Big DataFile ProcessingJava
0 likes · 13 min read
How to Find the Most Frequent Age in a 10 GB File Using Java Multithreading
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++ templatesObjective‑CRuntime
0 likes · 19 min read
Understanding the Implementation of weak Pointers in the Objective‑C Runtime
Senior Brother's Insights
Senior Brother's Insights
Jun 26, 2022 · Backend Development

How ZGC Achieves Sub‑10 ms Pauses and Scalable Memory Management

This article explains ZGC’s evolution from an experimental feature in JDK 11 to a production‑ready collector in JDK 15, detailing its sub‑10 ms pause guarantee, memory‑mapping architecture, colored pointers, region layout, read barriers, and the multi‑phase concurrent collection process that together deliver low‑latency, high‑throughput garbage collection for Java applications.

Colored PointersConcurrent GCGarbage Collection
0 likes · 16 min read
How ZGC Achieves Sub‑10 ms Pauses and Scalable Memory Management
Top Architect
Top Architect
Jun 24, 2022 · Fundamentals

Understanding JVM Memory Layout: Heap, Metaspace, Stacks, and Program Counter

This article explains the JVM memory architecture, covering the heap (young and old generations, Eden and Survivor spaces), Metaspace, virtual machine stacks, native method stacks, and the program counter register, while also illustrating key JVM parameters and bytecode execution with examples.

Garbage CollectionHeapJVM
0 likes · 13 min read
Understanding JVM Memory Layout: Heap, Metaspace, Stacks, and Program Counter
Liangxu Linux
Liangxu Linux
Jun 22, 2022 · Fundamentals

Understanding Linux Memory Management: From Process Allocation to OOM and Cache

This article provides a comprehensive walkthrough of Linux kernel memory management, covering process address space layout, memory allocation mechanisms, OOM selection criteria, where allocated memory resides, and both manual and automatic memory reclamation techniques, complete with code examples and diagrams.

CacheLinuxOOM
0 likes · 20 min read
Understanding Linux Memory Management: From Process Allocation to OOM and Cache
Zuoyebang Tech Team
Zuoyebang Tech Team
Jun 9, 2022 · Frontend Development

Re‑engineering a Live‑Streaming Frontend to Cut Black‑Screen Errors & Boost Performance

Facing fragmented devices, high memory usage, and unreliable signaling, the Zuoyebang live‑streaming frontend was redesigned with container‑based isolation, a modular SDK, and state‑synchronization mechanisms, resulting in timely memory reclamation, reduced CPU load, and dramatically lower black‑screen incidents.

Container ArchitectureFrontendPerformance Optimization
0 likes · 13 min read
Re‑engineering a Live‑Streaming Frontend to Cut Black‑Screen Errors & Boost Performance
Open Source Linux
Open Source Linux
Jun 6, 2022 · Fundamentals

Unlock 50,000 Words of C/C++ Mastery: Key Concepts, Code & Tips

This comprehensive C/C++ knowledge base covers everything from basic syntax, const, static, and this pointers to advanced topics like inline functions, virtual methods, smart pointers, STL containers, data structures, algorithms, operating system concepts, networking layers, and common interview problems, complete with code examples and diagrams.

AlgorithmsC++Data Structures
0 likes · 66 min read
Unlock 50,000 Words of C/C++ Mastery: Key Concepts, Code & Tips
TAL Education Technology
TAL Education Technology
Jun 2, 2022 · Game Development

Unity Memory Management and Performance Optimization Guide

This article provides a comprehensive introduction to Unity memory concepts—including physical, virtual, native, and managed memory—and offers practical optimization techniques for native and managed resources, graphics rendering, and tooling to improve game performance on both desktop and mobile platforms.

Game DevelopmentManaged MemoryNative Memory
0 likes · 23 min read
Unity Memory Management and Performance Optimization Guide
21CTO
21CTO
Jun 1, 2022 · Fundamentals

How Python 3.11 Boosts Speed by Up to 60% – The Secrets Behind Faster CPython

Python 3.11, slated for release in October 2022, delivers a 10‑60% performance boost over 3.10 thanks to the Microsoft‑backed Faster CPython project, which introduces adaptive specialization, memory‑allocator refinements, and several low‑level optimizations that trade a modest memory increase for faster execution.

CPythonInterpreter OptimizationPEP 659
0 likes · 5 min read
How Python 3.11 Boosts Speed by Up to 60% – The Secrets Behind Faster CPython
IT Services Circle
IT Services Circle
Jun 1, 2022 · Backend Development

Key Knowledge Points for C++ Backend Development (Image Overview)

This article presents a series of images that quickly review essential C++ backend development topics, highlighting low‑level concepts such as memory management, inter‑process communication, network programming, and the importance of databases and Linux, while comparing C++ to Java backend routes.

Backend DevelopmentC++Databases
0 likes · 3 min read
Key Knowledge Points for C++ Backend Development (Image Overview)
IT Services Circle
IT Services Circle
May 24, 2022 · Fundamentals

Understanding Linux Memory Management, Page Reclamation, and OOM Killer

This article explains Linux virtual memory concepts, the process of memory allocation, page fault handling, background and direct memory reclamation methods, LRU-based page types, NUMA considerations, tuning parameters like swappiness and min_free_kbytes, and strategies to prevent OOM killer termination.

LinuxNUMAOOM killer
0 likes · 18 min read
Understanding Linux Memory Management, Page Reclamation, and OOM Killer
Java One
Java One
May 14, 2022 · Fundamentals

Master Java Constructors, Method Overloading, and Memory Management: A Deep Dive

This article explains Java constructors, the importance of providing a no‑arg constructor, method overloading rules and type promotion, the use of the this and static keywords, memory cleanup strategies, garbage‑collector algorithms, JIT compilation, member initialization order, and enum usage with clear code examples.

ConstructorsGarbage CollectionMethod Overloading
0 likes · 15 min read
Master Java Constructors, Method Overloading, and Memory Management: A Deep Dive
Ziru Technology
Ziru Technology
May 13, 2022 · Fundamentals

Understanding VSZ, RSS, PSS, PageCache and Swap: A Linux Memory Primer

This article explains Linux memory metrics VSZ, RSS, and PSS, illustrates them with a roommate analogy, details PageCache and its role in I/O, describes swap behavior and the swappiness setting, and introduces zero‑copy techniques to reduce data copying and context switches.

LinuxPageCacheRSS
0 likes · 9 min read
Understanding VSZ, RSS, PSS, PageCache and Swap: A Linux Memory Primer
Code Ape Tech Column
Code Ape Tech Column
May 12, 2022 · Databases

Thirteen Rules for Optimizing Redis Performance

This article outlines thirteen practical Redis performance‑optimization rules, covering command complexity, key expiration, data‑structure selection, persistence settings, hardware choices, clustering, and memory‑fragmentation monitoring to help developers maximize throughput and reduce latency in production environments.

BackendCachingDatabase
0 likes · 12 min read
Thirteen Rules for Optimizing Redis Performance
DaTaobao Tech
DaTaobao Tech
May 6, 2022 · Mobile Development

hyengine: A Unified Mobile Script Engine with JIT, Optimizations, and GC

hyengine is a lightweight, high‑performance mobile execution engine that unifies WebAssembly, JavaScript, Python and Lua via a compiler and VM, offering JIT compilation, register allocation, inline‑cache optimizations, a custom allocator (hymalloc) and a concurrent three‑color garbage collector (hygc), achieving substantial speed‑ups on macOS and Android.

Garbage CollectionJITJavaScript
0 likes · 34 min read
hyengine: A Unified Mobile Script Engine with JIT, Optimizations, and GC
vivo Internet Technology
vivo Internet Technology
Apr 27, 2022 · Databases

Redis Memory Management and Optimization Practices

The article explains Redis’s in‑memory architecture, detailing memory components, object encodings, buffer limits, fragmentation, and forked‑process overhead, and offers practical optimization tips—such as using compact encodings, controlling client buffers, disabling THP, and enabling active defragmentation—illustrated by real‑world case studies.

OptimizationRedismemory management
0 likes · 24 min read
Redis Memory Management and Optimization Practices
IT Services Circle
IT Services Circle
Apr 16, 2022 · Fundamentals

Can Programs Run Without an Operating System? Exploring Bare‑Metal Programming

The article argues that programs can indeed run without an operating system by treating the OS itself as a program, discusses the challenges of bootstrapping, memory management, multitasking, device drivers, and concludes that bare‑metal programming lets developers fully control hardware, effectively creating their own minimal OS.

Bare MetalBootstrappingDevice Drivers
0 likes · 5 min read
Can Programs Run Without an Operating System? Exploring Bare‑Metal Programming
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Apr 7, 2022 · Frontend Development

Understanding JavaScript Memory Management and Common Memory Leaks

This article explains JavaScript's memory lifecycle, defines memory leaks, enumerates typical leak patterns such as accidental globals, timers, closures and DOM references, and describes the underlying garbage‑collection strategies (mark‑and‑sweep and reference counting) together with practical mitigation techniques.

Frontend DevelopmentGarbage CollectionJavaScript
0 likes · 18 min read
Understanding JavaScript Memory Management and Common Memory Leaks
Tencent Cloud Developer
Tencent Cloud Developer
Mar 28, 2022 · Fundamentals

Go Performance Optimization: Data Structures, Memory Management, and Benchmarking

The guide details Go performance optimization techniques—including avoiding reflection‑based conversions, using proper capacity hints, preferring strconv over fmt, employing custom binary functions, optimizing string handling, struct layout, loop patterns, and sync.Pool reuse—backed by benchmarks that demonstrate significant speed and memory gains.

Gomemory managementperformance
0 likes · 37 min read
Go Performance Optimization: Data Structures, Memory Management, and Benchmarking
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 28, 2022 · Backend Development

Understanding Java's sun.misc.Unsafe: Construction, Core Functions, and Usage

This article explains the purpose, construction, and most important capabilities of Java's sun.misc.Unsafe class—including memory management, object instantiation, class loading, offset handling, array operations, thread scheduling, CAS, and memory fences—while providing code examples and practical guidance for developers.

Javalow‑level programmingmemory management
0 likes · 12 min read
Understanding Java's sun.misc.Unsafe: Construction, Core Functions, and Usage
ITPUB
ITPUB
Mar 23, 2022 · Databases

Optimizing Distributed Database Sorting: Memory, Disk, and Proxy Strategies

This article examines the architecture of distributed databases, identifies challenges in sorting large result sets across shards, and presents step-by-step memory‑based, disk‑based, and incremental proxy sorting techniques, including buffer sizing, priority‑queue merging, and trade‑offs to avoid OOM and excessive I/O.

ProxySortingdistributed databases
0 likes · 12 min read
Optimizing Distributed Database Sorting: Memory, Disk, and Proxy Strategies
Top Architect
Top Architect
Mar 12, 2022 · Databases

Understanding Redis Eviction Policies and Memory Management

This article explains Redis's in‑memory database architecture, detailing data locality, various eviction policies such as LRU, LFU, random and TTL, their configuration via maxmemory settings, and provides code examples of the eviction process and memory‑freeing functions.

DatabasesLFULRU
0 likes · 17 min read
Understanding Redis Eviction Policies and Memory Management
Efficient Ops
Efficient Ops
Mar 9, 2022 · Fundamentals

Understanding Linux: Kernel, Memory, Processes, and File Systems Explained

This comprehensive guide explores the core components of a Linux system—including the kernel, memory management, process scheduling, file system architecture, device drivers, networking, and shell—while also covering disk partitions, mounting, and practical command examples for system administration.

file systemkernelmemory management
0 likes · 36 min read
Understanding Linux: Kernel, Memory, Processes, and File Systems Explained
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Mar 4, 2022 · Operations

Understanding Linux mlock and munlock: Memory Locking and Reclamation Mechanisms on arm64

On arm64 Linux kernels (e.g., 5.10.27), the mlock system call marks VMAs with VM_LOCKED, forces page faults, sets the PG_mlocked flag and moves pages into the unevictable LRU so they cannot be reclaimed, while munlock clears these flags and returns pages to regular LRU lists, guaranteeing resident memory for latency‑sensitive applications.

LRULinuxkernel
0 likes · 7 min read
Understanding Linux mlock and munlock: Memory Locking and Reclamation Mechanisms on arm64
Architects' Tech Alliance
Architects' Tech Alliance
Feb 28, 2022 · Fundamentals

Comprehensive Guide to Linux Memory Management and Allocation Algorithms

This article provides an in‑depth overview of Linux memory architecture, including address spaces, segmentation and paging, memory allocation strategies such as the buddy and slab allocators, kernel and user‑space memory pools, DMA considerations, common pitfalls, and practical tools for monitoring and optimizing memory usage.

DMALinuxSlab Allocator
0 likes · 19 min read
Comprehensive Guide to Linux Memory Management and Allocation Algorithms
Liangxu Linux
Liangxu Linux
Feb 19, 2022 · Fundamentals

How Linux Manages User and Kernel Memory: A Deep Dive into mm_struct and Virtual Address Layout

This article explains the complete memory layout of a Linux process, detailing user‑space structures like mm_struct and vm_area_struct, the role of TASK_SIZE, how ELF binaries are loaded, the sys_brk implementation, and the differences between 32‑bit and 64‑bit kernel virtual address spaces.

Virtual Address Spacememory managementmm_struct
0 likes · 21 min read
How Linux Manages User and Kernel Memory: A Deep Dive into mm_struct and Virtual Address Layout
Open Source Linux
Open Source Linux
Feb 15, 2022 · Fundamentals

Understanding Processes, Threads, Memory & File Management in Operating Systems

This article explains the differences between processes and threads, outlines process states, describes inter‑process communication methods, details memory allocation strategies and page‑replacement algorithms, covers file allocation techniques, disk I/O scheduling, and outlines deadlock conditions and prevention methods.

File SystemsThreadsdeadlock
0 likes · 20 min read
Understanding Processes, Threads, Memory & File Management in Operating Systems
Liangxu Linux
Liangxu Linux
Feb 10, 2022 · Operations

Master Linux Memory Insights with smem: Install, Use, and Visualize

This guide explains how to install the Linux smem tool, use its various options to report RSS, USS, and PSS memory metrics, filter results for specific processes or users, and generate visual pie and bar charts with Python's matplotlib for clearer memory analysis.

PSSmemory managementsmem
0 likes · 6 min read
Master Linux Memory Insights with smem: Install, Use, and Visualize
Full-Stack Trendsetter
Full-Stack Trendsetter
Jan 27, 2022 · Fundamentals

Understanding the Difference Between JavaScript Stack and Heap Memory

The article explains how JavaScript engines store variables in stack and heap memory, clarifies why const primitives are immutable while object properties can change, shows that new objects reside in heap, and discusses allocation efficiency and garbage‑collection behavior of both memory regions.

Garbage CollectionHeap MemoryJavaScript
0 likes · 5 min read
Understanding the Difference Between JavaScript Stack and Heap Memory
Ops Development Stories
Ops Development Stories
Jan 20, 2022 · Fundamentals

Mastering JVM Garbage Collection: Algorithms, Collectors, and Tuning

This article explains the theory behind JVM garbage collection algorithms, details various collectors such as Serial, Parallel, CMS, and G1, compares their strengths and weaknesses, and explores advanced concepts like three‑color marking, write barriers, SATB, and memory management parameters.

CMSGC AlgorithmsGarbage Collection
0 likes · 19 min read
Mastering JVM Garbage Collection: Algorithms, Collectors, and Tuning
IT Xianyu
IT Xianyu
Jan 19, 2022 · Databases

Understanding Linux Memory Usage, Buff/Cache Cleanup, and SQL Join Optimization

This article explains how to inspect and clear Linux memory buffers, details the information shown by the free command, and provides a comprehensive overview of SQL join types, their performance impact, and optimization techniques such as indexing, join buffer tuning, and algorithm choices.

BuffCacheDatabase PerformanceJOIN optimization
0 likes · 7 min read
Understanding Linux Memory Usage, Buff/Cache Cleanup, and SQL Join Optimization
Qunar Tech Salon
Qunar Tech Salon
Jan 13, 2022 · Databases

Root Cause Analysis of MySQL Memory Spike Caused by Excessive dentry Allocation from Mis‑configured yum makecache Cron

The article details a MySQL memory‑usage incident at Qunar where abnormal slab memory, especially dentry allocation, caused a rapid increase in used memory after a mis‑configured yum makecache cron job, and explains the investigation steps, Linux memory concepts, diagnostic commands, and the corrective actions taken.

DentryLinuxMySQL
0 likes · 14 min read
Root Cause Analysis of MySQL Memory Spike Caused by Excessive dentry Allocation from Mis‑configured yum makecache Cron
Big Data Technology & Architecture
Big Data Technology & Architecture
Dec 23, 2021 · Big Data

Key Spark Configuration Parameters and Their Explanations

This article presents a comprehensive list of essential Spark configuration settings—including executor memory, off‑heap memory, memory fractions, shuffle options, and adaptive query execution parameters—each accompanied by a concise description to help users fine‑tune Spark performance.

Adaptive Query ExecutionBig DataShuffle
0 likes · 6 min read
Key Spark Configuration Parameters and Their Explanations
Kuaishou Tech
Kuaishou Tech
Dec 22, 2021 · Mobile Development

Swift Performance Optimization: Compilation Speed, Memory Usage, and Runtime Improvements

This article examines various Swift performance optimization techniques—including compilation speed improvements, memory allocation strategies, struct versus class trade‑offs, enum usage, collection handling, lazy sequences, bridge reduction, and function dispatch—providing practical code examples and analysis to help developers write faster, more efficient Swift code.

CollectionsEnumsSwift
0 likes · 16 min read
Swift Performance Optimization: Compilation Speed, Memory Usage, and Runtime Improvements
Kuaishou Frontend Engineering
Kuaishou Frontend Engineering
Dec 20, 2021 · Mobile Development

Boost Swift Performance: Compilation, Memory, and Runtime Optimizations

This article explores practical Swift performance enhancements, covering compilation‑time reductions through smarter type inference, memory‑usage improvements via structs, enums, and collection strategies, and runtime speed gains by understanding function dispatch and applying final, private, and lazy sequence techniques.

Performance OptimizationSwiftcompilation
0 likes · 17 min read
Boost Swift Performance: Compilation, Memory, and Runtime Optimizations
Efficient Ops
Efficient Ops
Dec 15, 2021 · Fundamentals

Understanding Linux: Kernel, Shell, Filesystem, and Process Management

This article provides a comprehensive overview of Linux system architecture, covering the kernel, memory and process management, virtual and physical filesystems, device drivers, networking, shell types, file types, directory structures, partitioning, mounting, and link mechanisms, all illustrated with diagrams and command examples.

FilesystemLinksLinux
0 likes · 35 min read
Understanding Linux: Kernel, Shell, Filesystem, and Process Management
BaiPing Technology
BaiPing Technology
Dec 14, 2021 · Frontend Development

Why Vue 3 Relies on WeakMap for Reactivity and Memory‑Safe Caching

This article explains how Vue 3 uses a WeakMap as a cache to avoid duplicate proxies, why WeakMap is preferred over Map for memory‑safe reactive objects, and explores WeakMap fundamentals, its methods, garbage‑collection strategies, and practical applications such as DOM storage and private class fields.

Garbage CollectionWeakMapmemory management
0 likes · 13 min read
Why Vue 3 Relies on WeakMap for Reactivity and Memory‑Safe Caching
Python Crawling & Data Mining
Python Crawling & Data Mining
Dec 12, 2021 · Fundamentals

Unlock Python’s Numeric Types: Integers, Floats, Complex & Memory Tricks

This article explains Python’s numeric types—including integers, floats, and complex numbers—covers their immutability, memory representation such as the small integer object pool, demonstrates type conversion functions, and introduces the math library for basic scientific calculations, all illustrated with clear code examples.

FloatsIntegersMath Library
0 likes · 9 min read
Unlock Python’s Numeric Types: Integers, Floats, Complex & Memory Tricks
Big Data Technology & Architecture
Big Data Technology & Architecture
Dec 6, 2021 · Big Data

Understanding Spark’s Memory Model: Unified Memory Management, On‑Heap and Off‑Heap Memory, and Configuration

This article explains Spark’s unified memory management model, detailing the division between on‑heap and off‑heap memory, the roles of execution, storage, user, and reserved memory, configuration parameters, dynamic allocation, and how these concepts affect performance and resource utilization.

Execution MemoryOff-HeapSpark
0 likes · 17 min read
Understanding Spark’s Memory Model: Unified Memory Management, On‑Heap and Off‑Heap Memory, and Configuration
Java High-Performance Architecture
Java High-Performance Architecture
Dec 3, 2021 · Fundamentals

Unlocking JVM Secrets: Deep Dive into Memory, GC, Class Files, and Method Dispatch

This comprehensive guide explores the inner workings of the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, class‑file structure, bytecode instructions, class loading mechanisms, and method dispatch strategies, providing clear explanations and code examples for developers seeking a deeper understanding of JVM fundamentals.

Garbage CollectionJVMbytecode
0 likes · 41 min read
Unlocking JVM Secrets: Deep Dive into Memory, GC, Class Files, and Method Dispatch
Python Programming Learning Circle
Python Programming Learning Circle
Dec 2, 2021 · Fundamentals

Understanding Python Garbage Collection: Reference Counting, Mark‑Sweep, and Generational GC

This article explains how Python’s automatic garbage collection works, covering reference counting, the problems of cyclic references, the mark‑and‑sweep algorithm, generational collection, default thresholds, and when and how to manually control the collector with code examples.

Garbage CollectionGenerational GCMark‑Sweep
0 likes · 7 min read
Understanding Python Garbage Collection: Reference Counting, Mark‑Sweep, and Generational GC
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Nov 26, 2021 · Fundamentals

Understanding V8 Engine Memory Allocation and Garbage Collection

This article explains how the V8 JavaScript engine allocates memory, why garbage collection is necessary, describes the memory layout of new and old generations, reviews common GC algorithms such as reference counting, mark‑sweep, mark‑compact and incremental marking, and offers practical tips for writing high‑performance JavaScript code.

Garbage CollectionJavaScriptV8
0 likes · 22 min read
Understanding V8 Engine Memory Allocation and Garbage Collection
Code Ape Tech Column
Code Ape Tech Column
Nov 25, 2021 · Backend Development

Comprehensive Guide to JVM Memory Areas, Garbage Collection, and Related Concepts

This article provides an in‑depth overview of the JVM runtime data structures, memory regions, garbage‑collection algorithms, GC roots, reference types, stop‑the‑world pauses, OopMap, safe points, stack‑overflow handling, class‑loading mechanisms, the parent‑delegation model, object stack allocation, and object layout, offering practical insights for Java developers preparing for interviews.

Garbage CollectionJVMJava
0 likes · 29 min read
Comprehensive Guide to JVM Memory Areas, Garbage Collection, and Related Concepts
Practical DevOps Architecture
Practical DevOps Architecture
Nov 23, 2021 · Fundamentals

Understanding Memory Leaks, Memory Overflow, Young GC STW, Major vs Full GC, and Direct Memory in Java

This article explains the difference between memory leaks and overflow, whether young GC triggers stop‑the‑world pauses, distinguishes major GC from full GC, and describes Java's direct memory usage, providing clear insights into Java memory management and performance considerations.

Garbage Collectiondirect memorymemory management
0 likes · 4 min read
Understanding Memory Leaks, Memory Overflow, Young GC STW, Major vs Full GC, and Direct Memory in Java
Programmer DD
Programmer DD
Nov 19, 2021 · Fundamentals

Mastering JVM Memory and Garbage Collection: A Comprehensive Guide

This article provides an in-depth exploration of Java's JVM memory architecture, garbage collection algorithms, class file structure, class loading process, bytecode execution, and method dispatch mechanisms, offering practical code examples and visual diagrams to help developers understand and optimize JVM performance.

Garbage CollectionJVMJava
0 likes · 44 min read
Mastering JVM Memory and Garbage Collection: A Comprehensive Guide
Architects' Tech Alliance
Architects' Tech Alliance
Nov 17, 2021 · Fundamentals

Understanding Operating System Evolution, Boundaries, and Memory Management

The article explains how operating systems acquire execution control, traces their historical evolution from early mainframes to modern mobile platforms, and details memory management techniques in real and protected modes, highlighting the roles of BIOS, boot loaders, virtual memory, and the shifting boundaries between hardware, OS, and browsers.

Boot ProcessSystem architectureVirtual Memory
0 likes · 20 min read
Understanding Operating System Evolution, Boundaries, and Memory Management
Architect
Architect
Nov 10, 2021 · Fundamentals

Deep Dive into JVM: Class Loading, Memory Management, Debugging, Hot Deployment, and Performance Tuning

This comprehensive article explains the inner workings of the Java Virtual Machine, covering class file structure, class loaders, memory layout, garbage collection, execution engine, debugging via JPDA, hot deployment, hot swapping, and performance tuning techniques, providing practical code examples and configuration tips.

DebuggingJVMPerformance tuning
0 likes · 74 min read
Deep Dive into JVM: Class Loading, Memory Management, Debugging, Hot Deployment, and Performance Tuning
Su San Talks Tech
Su San Talks Tech
Nov 8, 2021 · Fundamentals

Mastering JVM Memory: Layout, GC Algorithms, and Tuning Tips

This comprehensive guide explains the JVM memory layout, class‑loading and object‑creation process, the parent‑delegation model, various garbage‑collection algorithms and collectors, GC roots, triggers for YGC and Full GC, and practical tuning parameters to improve Java application performance.

Garbage CollectionJVMPerformance tuning
0 likes · 15 min read
Mastering JVM Memory: Layout, GC Algorithms, and Tuning Tips
Laravel Tech Community
Laravel Tech Community
Nov 2, 2021 · Operations

Understanding Virtual Memory: Concepts, Paging, and Management in Linux

This article explains the fundamentals of virtual memory, including paging, page tables, swap, and Linux management commands, highlighting how virtual memory abstracts physical addresses, resolves process memory conflicts, and enhances security and data sharing while providing practical tips for monitoring and tuning memory usage.

LinuxPage TablePaging
0 likes · 9 min read
Understanding Virtual Memory: Concepts, Paging, and Management in Linux
JavaEdge
JavaEdge
Oct 31, 2021 · Backend Development

Master JVM Memory & GC: 20 Essential Interview Questions Explained

This article provides a comprehensive, interview‑focused guide to the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, reference types, GC roots, STW pauses, OopMap, safe points, stack overflow, class loading, the parent‑delegation model, stack allocation, and object layout, all with clear explanations and diagrams.

Garbage CollectionInterviewJVM
0 likes · 31 min read
Master JVM Memory & GC: 20 Essential Interview Questions Explained
Python Programming Learning Circle
Python Programming Learning Circle
Oct 30, 2021 · Fundamentals

Lesser‑Known Python Standard Library Features and Techniques

This article explores several lesser‑known Python standard‑library techniques—including string sanitization, iterator slicing with itertools.islice, skipping initial lines, enforcing keyword‑only arguments, creating custom context managers, using __slots__ for memory savings, limiting CPU/memory via the resource module, controlling module exports with __all__, and simplifying comparisons with functools.total_ordering.

Iteratorscontext managersimport-control
0 likes · 7 min read
Lesser‑Known Python Standard Library Features and Techniques
ITPUB
ITPUB
Oct 28, 2021 · Fundamentals

5 Common C Bugs Every Programmer Should Avoid

This article outlines five typical C programming mistakes—uninitialized variables, array out‑of‑bounds access, string overflow, double free, and invalid file pointers—explaining why they occur, showing concrete code examples with varied outputs, and offering practical safeguards to prevent them.

C Programmingarray boundscommon bugs
0 likes · 13 min read
5 Common C Bugs Every Programmer Should Avoid
Liangxu Linux
Liangxu Linux
Oct 26, 2021 · Fundamentals

5 Sneaky C Bugs Every Programmer Should Avoid

This article lists five common C programming mistakes—uninitialized variables, array out‑of‑bounds access, string overflow, double free, and invalid file pointers—explains why they occur, shows concrete code examples with typical output, and offers practical ways to prevent each bug.

C ProgrammingInitializationarray bounds
0 likes · 13 min read
5 Sneaky C Bugs Every Programmer Should Avoid
JavaEdge
JavaEdge
Oct 26, 2021 · Fundamentals

Master Java Garbage Collection: Visual Guide to Algorithms and Roots

This article explains how the JVM determines object liveness, describes reference counting and reachability analysis, lists GC Roots, and provides clear visual and code examples of the main garbage‑collection algorithms—mark‑sweep, copy, mark‑compact, and generational collection—highlighting their advantages, drawbacks, and typical use cases.

GC AlgorithmsGarbage CollectionJVM
0 likes · 12 min read
Master Java Garbage Collection: Visual Guide to Algorithms and Roots
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 13, 2021 · Fundamentals

JVM Core Concepts: Memory Areas, Class Loading, Object Creation, and Garbage Collection

This article provides a comprehensive overview of the Java Virtual Machine, explaining its main purpose, memory regions, class‑loading mechanism, object creation process, memory allocation strategies, object layout, reference handling, garbage‑collection theories, algorithms, and common JVM tuning commands.

Garbage CollectionJVMJava
0 likes · 51 min read
JVM Core Concepts: Memory Areas, Class Loading, Object Creation, and Garbage Collection
Programmer DD
Programmer DD
Oct 13, 2021 · Backend Development

Why Netty Introduced FastThreadLocal and How It Works

This article explains the motivation behind Netty's FastThreadLocal, compares it with JDK ThreadLocal, details its internal implementation—including InternalThreadLocalMap, FastThreadLocalThread, and key methods like get()—and discusses its performance benefits, resource recycling mechanisms, and practical usage in Netty's ByteBuf allocation.

FastThreadLocalJavaNetty
0 likes · 13 min read
Why Netty Introduced FastThreadLocal and How It Works
Top Architect
Top Architect
Oct 6, 2021 · Fundamentals

Understanding JVM Memory Layout and Allocation

This article provides a comprehensive overview of the Java Virtual Machine memory architecture, covering heap layout, allocation, tuning parameters, garbage collection, stack frames, method area, metaspace, native method stack, program counter, direct memory, and code cache, with practical code examples and diagnostics.

HeapJVMJava
0 likes · 16 min read
Understanding JVM Memory Layout and Allocation
Efficient Ops
Efficient Ops
Sep 27, 2021 · Fundamentals

How Linux Kernel Manages Memory: Allocation, OOM, and Recovery

This article explains Linux kernel memory management by covering process address space layout, allocation mechanisms, OOM killer behavior, overcommit settings, various types of file and anonymous mappings, tmpfs usage, and both manual and automatic memory reclamation techniques.

LinuxOOMSwap
0 likes · 20 min read
How Linux Kernel Manages Memory: Allocation, OOM, and Recovery
Liangxu Linux
Liangxu Linux
Sep 26, 2021 · Operations

Master Linux Swap: When, How Much, and How to Optimize Performance

This guide explains what Linux swap is, its advantages and drawbacks, how to size it for different memory configurations, and provides step‑by‑step commands for creating, managing, and tuning swap partitions or files, including swappiness and ZFS considerations.

Performance tuningSwapSystem Administration
0 likes · 15 min read
Master Linux Swap: When, How Much, and How to Optimize Performance
Programmer DD
Programmer DD
Sep 24, 2021 · Backend Development

Master JVM Startup Flags: Decode GC Logs and Optimize Memory

This guide explains the most common JVM startup flags for controlling garbage collection logging, heap sizing, class loading monitoring, and out‑of‑memory handling, providing sample outputs and detailed interpretations to help developers tune memory usage and diagnose performance issues in large Java applications.

JVMJavaStartup Flags
0 likes · 10 min read
Master JVM Startup Flags: Decode GC Logs and Optimize Memory
Programmer DD
Programmer DD
Sep 17, 2021 · Backend Development

Avoid Out‑of‑Memory Errors: Properly Configure Spring Boot Async Thread Pool

This article explains why using @Async in Spring Boot can cause memory overflow when many requests trigger parallel tasks, examines the default thread‑pool settings that lead to unbounded queues, and provides step‑by‑step configuration of a safe thread pool to prevent out‑of‑memory failures.

AsyncJavaSpring Boot
0 likes · 11 min read
Avoid Out‑of‑Memory Errors: Properly Configure Spring Boot Async Thread Pool
WeDoctor Frontend Technology
WeDoctor Frontend Technology
Sep 15, 2021 · Fundamentals

Ace JavaScript Interviews: Master Variables, Types, Memory & Garbage Collection

This article provides a comprehensive JavaScript guide covering primitive and reference types, Symbol and BigInt nuances, type‑checking operators, stack vs heap memory, deep and shallow copying techniques, and practical garbage‑collection strategies to help developers ace interview questions.

Garbage CollectionInterview Preparationdeep copy
0 likes · 14 min read
Ace JavaScript Interviews: Master Variables, Types, Memory & Garbage Collection
Kuaishou Tech
Kuaishou Tech
Sep 10, 2021 · Mobile Development

Analyzing and Resolving a Main Thread ↔ JavaScriptCore Heap Collector Thread Deadlock on iOS 13

This article investigates a deadlock between the Main Thread and the JavaScriptCore Heap Collector Thread on iOS 13, explains the underlying mutex and RunLoop interactions, reproduces the issue with CFTimer‑based timers, and proposes an AutoReleasePool‑wrapped solution along with best‑practice recommendations for JavaScriptCore usage.

RunLoopdeadlockiOS
0 likes · 17 min read
Analyzing and Resolving a Main Thread ↔ JavaScriptCore Heap Collector Thread Deadlock on iOS 13
Architect
Architect
Sep 9, 2021 · Fundamentals

Understanding JVM Memory Structure: Areas, Allocation, and Tuning

This article provides a comprehensive overview of the Java Virtual Machine memory layout, explaining each region such as the heap, metaspace, stack, program counter, direct memory and code cache, along with allocation strategies, tuning parameters, and practical OOM demonstrations.

Garbage CollectionHeapJVM
0 likes · 16 min read
Understanding JVM Memory Structure: Areas, Allocation, and Tuning
WeChat Client Technology Team
WeChat Client Technology Team
Sep 8, 2021 · Mobile Development

Uncovering Hidden Android Thread Pitfalls: Memory Leaks, Monitoring, and Hook Solutions

This article explores obscure Android thread issues—including uncontrolled thread creation, stack memory leaks, and the impact of thread‑priority settings—while presenting monitoring techniques, a pthread hook implementation, and performance considerations to help developers detect and resolve thread‑related crashes.

AndroidHookThread Leak
0 likes · 15 min read
Uncovering Hidden Android Thread Pitfalls: Memory Leaks, Monitoring, and Hook Solutions
Su San Talks Tech
Su San Talks Tech
Sep 7, 2021 · Fundamentals

Master Java Fundamentals: Essential Interview Topics and Core Concepts

This comprehensive guide covers Java platform basics, JVM/JRE/JDK relationships, bytecode advantages, new features since Java 8, core OOP principles, common interview questions, exception handling, garbage collection, reference types, and practical code examples to solidify your Java expertise.

ExceptionsInterviewJVM
0 likes · 45 min read
Master Java Fundamentals: Essential Interview Topics and Core Concepts
Code Ape Tech Column
Code Ape Tech Column
Sep 1, 2021 · Fundamentals

Understanding Java Object Memory Layout with JOL

This article explains how Java objects are stored in memory, covering the object header, instance data, alignment padding, lock states, pointer compression, and field reordering, and demonstrates how to inspect these structures using the OpenJDK JOL tool with practical code examples.

JOLJVMJava
0 likes · 20 min read
Understanding Java Object Memory Layout with JOL
Kuaishou Frontend Engineering
Kuaishou Frontend Engineering
Aug 30, 2021 · Mobile Development

Why Does NSString Leak in Long‑Running Threads? Exploring ARC and AutoreleasePool

An in‑depth analysis of a memory‑growth issue observed in a Kuaishou live‑stream app reveals how ARC, autorelease pools, and NSString’s class‑cluster implementation interact, why @autoreleasepool blocks resolve the leak, and how compiler optimizations and thread‑local pools affect object release in long‑running C++ threads.

ARCAutoreleasePoolNSString
0 likes · 23 min read
Why Does NSString Leak in Long‑Running Threads? Exploring ARC and AutoreleasePool
Xiaolei Talks DB
Xiaolei Talks DB
Aug 25, 2021 · Databases

Fixing Aerospike Cluster Outage: Network Glitches, Memory Limits, and Rebalancing

After a network disruption caused Paxos messages to be ignored and memory shortages prevented data migration, this article details how the Aerospike cluster became unavailable, the diagnostic logs, and the step‑by‑step remediation involving node restarts, memory tuning, and adding new nodes for load balancing.

AerospikeData Rebalancingdatabase troubleshooting
0 likes · 12 min read
Fixing Aerospike Cluster Outage: Network Glitches, Memory Limits, and Rebalancing
Architect's Tech Stack
Architect's Tech Stack
Aug 24, 2021 · Backend Development

Common JVM Startup Parameters and Their Usage

This article introduces the most frequently used JVM startup parameters, explains their effects on garbage collection, heap configuration, class loading monitoring, and out‑of‑memory handling, and provides example outputs to help developers tune Java applications for large‑scale projects.

Garbage CollectionJVMJava
0 likes · 11 min read
Common JVM Startup Parameters and Their Usage
Open Source Linux
Open Source Linux
Aug 21, 2021 · Operations

Linux Huge Pages vs Transparent Huge Pages: Benefits, Risks, and Disabling Guide

This article explains the two types of Linux huge pages—static HugeTLB pages and dynamic Transparent Huge Pages—detailing their sizes, performance advantages, drawbacks, especially for Oracle workloads, and provides step‑by‑step instructions for checking status and permanently disabling THP via sysfs or GRUB.

Huge PagesLinuxTransparent Huge Pages
0 likes · 9 min read
Linux Huge Pages vs Transparent Huge Pages: Benefits, Risks, and Disabling Guide
Tencent Music Tech Team
Tencent Music Tech Team
Aug 18, 2021 · Mobile Development

Flutter Memory Management and Leak Prevention in the MOO Music App

The article details MOO Music’s experience with Flutter memory management, explaining the Dart heap, stack, and external memory structures, common leak sources such as missing listener deregistration, unbounded widget lists, retained timers, static references, and third‑party or engine bugs, and offers practical detection and optimization techniques.

FlutterMobile DevelopmentPerformance Optimization
0 likes · 10 min read
Flutter Memory Management and Leak Prevention in the MOO Music App