BestHub
Sign in
Tagged articles

Memory Management

1009 articles · Page 9 of 11
Architecture Digest
Architecture Digest
Mar 27, 2020 · Databases

Understanding Redis Memory Model: Objects, Allocation, and Internal Encoding

This article explains Redis's memory model by describing how to query memory usage, the roles of used_memory, used_memory_rss, mem_fragmentation_ratio, and mem_allocator, and then dives into the internal structures such as redisObject, SDS, jemalloc, and the encoding strategies for strings, lists, hashes, sets, and sorted sets.

Data StructuresMemory ManagementRedis
0 likes · 28 min read
Understanding Redis Memory Model: Objects, Allocation, and Internal Encoding
Architecture Digest
Architecture Digest
Mar 23, 2020 · Databases

Understanding Linux Buffer Cache and SQL Join Performance

This article explains how Linux memory statistics (free, top) report buffer/cache usage, how to clear it with sync and drop_caches, and then dives into SQL join concepts, types, optimization techniques, and MySQL join algorithms such as nested loop and block nested loop, highlighting their impact on performance.

Buffer CacheDatabase PerformanceLinux
0 likes · 7 min read
Understanding Linux Buffer Cache and SQL Join Performance
Xianyu Technology
Xianyu Technology
Mar 19, 2020 · Mobile Development

FlutterBoost 2.0 Architecture Upgrade and iOS Performance Improvements

FlutterBoost 2.0 redesigns the hybrid architecture by assigning each Flutter page its own controller and view, eliminating screenshot‑based transitions, fixing white/black screen glitches, enhancing iOS surface management and lifecycle callbacks, adding extensive documentation and tests, while acknowledging a ~10 MB per‑page memory cost mitigated through stack limits and reuse.

FlutterFlutterBoostHybrid App
0 likes · 12 min read
FlutterBoost 2.0 Architecture Upgrade and iOS Performance Improvements
vivo Internet Technology
vivo Internet Technology
Mar 11, 2020 · Big Data

Understanding Spark Executor Memory Management and the Unified Memory Model

The article explains Spark’s executor memory layout under the UnifiedMemoryManager, detailing on‑heap and off‑heap divisions, the four memory regions, default fraction settings, how storage and execution memory share space, and provides heuristics and tuning tips for avoiding OOM and optimizing performance.

ExecutorMemory ManagementPerformance Tuning
0 likes · 24 min read
Understanding Spark Executor Memory Management and the Unified Memory Model
Big Data Technology Architecture
Big Data Technology Architecture
Mar 4, 2020 · Databases

HBase Memory‑Related Performance Tuning Guide

This article explains how to optimize HBase performance by properly configuring JVM memory, selecting suitable garbage‑collection strategies, enabling MSLAB and BucketCache, and adjusting read/write cache ratios to reduce fragmentation and improve throughput.

CacheGarbage CollectionHBase
0 likes · 8 min read
HBase Memory‑Related Performance Tuning Guide
Liangxu Linux
Liangxu Linux
Mar 3, 2020 · Operations

Understanding Modern Operating Systems: From Hardware Basics to System Calls and Architecture

This comprehensive guide explains the fundamentals of operating systems, covering hardware components, CPU architecture, memory hierarchy, process and address space management, file systems, system calls, and various OS structures such as monolithic, layered, microkernel, and client‑server designs, providing clear examples and diagrams for each concept.

File SystemMemory ManagementOS Architecture
0 likes · 68 min read
Understanding Modern Operating Systems: From Hardware Basics to System Calls and Architecture
macrozheng
macrozheng
Mar 3, 2020 · Fundamentals

Mastering Java Garbage Collection: Algorithms, Regions, and Tuning Tips

This article provides a comprehensive overview of Java's automatic garbage collection, covering memory regions, identification methods, core algorithms such as mark‑sweep, copying, and generational collection, detailed explanations of various collectors (Serial, CMS, G1, etc.), and practical tuning insights for optimal performance.

Garbage CollectionJVMJava
0 likes · 31 min read
Mastering Java Garbage Collection: Algorithms, Regions, and Tuning Tips
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 2, 2020 · Databases

Redis Internals Explained: Data Structures, Memory Management & Use Cases

This article explores Redis, a high‑performance in‑memory key‑value store, detailing its core data types—String, List, Hash, Set, ZSet—the underlying structures such as SDS, quicklist, hashtable, and intset, and demonstrates practical usage patterns like caching, rate limiting, and inventory control.

Data StructuresIn-Memory DatabaseMemory Management
0 likes · 16 min read
Redis Internals Explained: Data Structures, Memory Management & Use Cases
Amap Tech
Amap Tech
Feb 27, 2020 · Mobile Development

Common Misunderstandings and Pitfalls in iOS Development – Foundation, UIKit, GCD and Best Practices

The article clarifies frequent iOS development misconceptions—from unnecessary observer removal and deprecated NSUserDefaults synchronization to block retain‑cycle tricks, responder‑chain versus hit‑testing differences, GCD queue optimizations, safe main‑queue detection, and proper cancellation of dispatch blocks—offering practical code guidance.

GCDMemory ManagementObjective‑C
0 likes · 17 min read
Common Misunderstandings and Pitfalls in iOS Development – Foundation, UIKit, GCD and Best Practices
Python Programming Learning Circle
Python Programming Learning Circle
Feb 12, 2020 · Fundamentals

9 Common Python Interview Questions and Answers

This article reviews nine frequently asked Python interview questions, covering lists, tuples, dictionaries, string reversal, memory management, sessions, cookies, tokens, GET vs POST, decorators, concurrency concepts, comprehensions, and generators, providing concise explanations and code examples.

Data StructuresMemory Managementgenerators
0 likes · 11 min read
9 Common Python Interview Questions and Answers
Programmer DD
Programmer DD
Feb 8, 2020 · Backend Development

Master Java Memory: Essential JVM Flags to Prevent OutOfMemory Errors

This guide explains the most important JVM parameters—such as -Xms, -Xmx, -Xss, and various -XX options—detailing how each setting influences heap, stack, and generation sizes and how proper configuration can avoid common OutOfMemoryError scenarios in Java applications.

JVMJavaMemory Management
0 likes · 3 min read
Master Java Memory: Essential JVM Flags to Prevent OutOfMemory Errors
Architecture Digest
Architecture Digest
Feb 4, 2020 · Databases

Comprehensive Guide to Redis: Usage, Performance, Data Types, Expiration Strategies, and Common Pitfalls

This article provides an in‑depth overview of Redis, covering why it is used for performance and concurrency, its single‑threaded architecture, core data structures and their scenarios, expiration policies, memory eviction strategies, consistency challenges, and practical solutions for cache penetration, snowballing, and concurrent key updates.

CachingData StructuresMemory Management
0 likes · 12 min read
Comprehensive Guide to Redis: Usage, Performance, Data Types, Expiration Strategies, and Common Pitfalls
MaGe Linux Operations
MaGe Linux Operations
Feb 1, 2020 · Operations

Unraveling Linux Memory Usage: From free to slab and PageTables

This article explains why the memory reported by ps RSS differs from the free command, walks through interpreting free -m output, demonstrates clearing caches, and shows how to account for process RSS, slab allocations, and PageTables to reconcile total used memory on Linux systems.

Memory ManagementPageTablesRSS
0 likes · 10 min read
Unraveling Linux Memory Usage: From free to slab and PageTables
Architect's Tech Stack
Architect's Tech Stack
Jan 18, 2020 · Fundamentals

JVM Memory Architecture: Overview, Heap, Metaspace, Stack, and More

This article provides a comprehensive overview of the Java Virtual Machine memory layout, covering heap regions, Metaspace, stack frames, native method stack, program counter, direct memory, and code cache, along with configuration tips, diagnostic commands, and illustrative code examples to help readers understand memory allocation and garbage collection.

Garbage CollectionJVMMemory Management
0 likes · 16 min read
JVM Memory Architecture: Overview, Heap, Metaspace, Stack, and More
Tencent Cloud Developer
Tencent Cloud Developer
Jan 7, 2020 · Mobile Development

Hippy Cross-Platform Framework: Common Debugging Methods and Troubleshooting Cases

The article introduces Tencent’s open‑source Hippy cross‑platform framework, outlines its developer‑friendly features and W3C compliance, and details common debugging techniques—including Chrome DevTools‑based services, jsbundle debugging, and memory monitoring—while presenting practical troubleshooting cases for UI updates, scrolling, performance, and iOS‑specific issues.

AndroidCross-PlatformHippy
0 likes · 12 min read
Hippy Cross-Platform Framework: Common Debugging Methods and Troubleshooting Cases
ITPUB
ITPUB
Dec 15, 2019 · Fundamentals

Understanding Linux: Kernel, Memory, Processes, Filesystems and More

An extensive guide walks through Linux’s core components—kernel, memory and process management, VFS, device drivers, networking, shells, filesystem hierarchy, partitioning, mounting, and link types—detailing their structures, key commands, and practical examples for system administrators and developers.

FilesystemLinuxMemory Management
0 likes · 35 min read
Understanding Linux: Kernel, Memory, Processes, Filesystems and More
Liangxu Linux
Liangxu Linux
Dec 12, 2019 · Fundamentals

Unlock Linux: A Deep Dive into Kernel, Memory, Processes, and Filesystems

This comprehensive guide explains the core components of a Linux system—including the kernel, memory management, process scheduling, device drivers, networking, shells, file‑system types, VFS architecture, mounting procedures, and link handling—providing clear examples, commands, and diagrams for each topic.

File SystemLinksMemory Management
0 likes · 35 min read
Unlock Linux: A Deep Dive into Kernel, Memory, Processes, and Filesystems
Architecture Digest
Architecture Digest
Dec 11, 2019 · Fundamentals

Understanding Java String Concatenation, Constant Pool, and Bytecode Behavior

This article explains how Java handles String literals and concatenation, detailing the roles of the String constant pool, the effects of the '+' operator invoking StringBuilder.append, the placement of resulting strings in the heap versus the pool, and demonstrates these concepts through bytecode analysis and code examples.

Constant PoolJavaMemory Management
0 likes · 12 min read
Understanding Java String Concatenation, Constant Pool, and Bytecode Behavior
vivo Internet Technology
vivo Internet Technology
Dec 4, 2019 · Mobile Development

Analysis of Glide Lifecycle Management in Android

The article dissects Glide’s lifecycle management by tracing how Glide.with creates a singleton RequestManager via RequestManagerRetriever, caches headless RequestManagerFragments, forwards Activity/Fragment callbacks through ActivityFragmentLifecycle to pause, resume, or clear image requests, monitors network changes with a ConnectivityMonitor, and responds to memory pressure via component callbacks, thereby integrating Android component lifecycles, connectivity, and memory management into its image‑loading engine.

AndroidGlideImage Loading
0 likes · 18 min read
Analysis of Glide Lifecycle Management in Android
Selected Java Interview Questions
Selected Java Interview Questions
Nov 29, 2019 · Fundamentals

Understanding Object Liveness Determination in Java: Reference Counting and Reachability Analysis

The article explains how Java determines whether an object is alive using two main garbage‑collection algorithms—Reference Counting and Reachability Analysis—detailing their mechanisms, limitations such as circular references, the role of GC Roots, finalization, and method‑area reclamation, with illustrative code examples.

Garbage CollectionJVMJava
0 likes · 6 min read
Understanding Object Liveness Determination in Java: Reference Counting and Reachability Analysis
JD Retail Technology
JD Retail Technology
Nov 28, 2019 · Mobile Development

Understanding iOS Property Modifiers and Common Retain Cycle Scenarios

This article explains iOS property attribute categories, the memory‑related modifiers assign, weak, strong and copy, clarifies why assign can cause dangling pointers while weak does not, and describes typical retain‑cycle cases caused by blocks, NSTimer and delegate misuse along with practical solutions.

ARCMemory ManagementProperty Modifiers
0 likes · 7 min read
Understanding iOS Property Modifiers and Common Retain Cycle Scenarios
Big Data Technology & Architecture
Big Data Technology & Architecture
Nov 18, 2019 · Big Data

Understanding JVM Garbage Collection and Flink Memory Management

This article explains the fundamentals of JVM garbage collection, its generational algorithms and associated performance issues, and then details Apache Flink's memory management architecture, including MemorySegment, off‑heap buffers, serialization mechanisms, and type information for efficient big‑data processing.

Big DataFlinkGarbage Collection
0 likes · 7 min read
Understanding JVM Garbage Collection and Flink Memory Management
360 Tech Engineering
360 Tech Engineering
Nov 7, 2019 · Fundamentals

Understanding mmap: Concepts, Usage, and Typical Applications in Linux

This article explains the Linux mmap system call, covering virtual address space fundamentals, how mmap interacts with the page cache and inode structures, typical use‑cases such as shared memory and anonymous mappings, code examples, and special considerations like alignment, copy‑on‑write and memory swapping.

Copy-on-WriteLinuxMemory Management
0 likes · 9 min read
Understanding mmap: Concepts, Usage, and Typical Applications in Linux
Architecture Digest
Architecture Digest
Nov 7, 2019 · Fundamentals

How the JVM Determines Object Liveness and Its Garbage Collection Algorithms

This article explains the JVM memory model, how the JVM decides whether an object is alive using reference counting and reachability analysis, and describes the main garbage‑collection algorithms—including mark‑sweep, mark‑compact, copying, and generational collection—along with their advantages and drawbacks.

Garbage CollectionGenerational GCJVM
0 likes · 8 min read
How the JVM Determines Object Liveness and Its Garbage Collection Algorithms
Selected Java Interview Questions
Selected Java Interview Questions
Nov 4, 2019 · Databases

Redis Expiration Strategies and Memory Eviction Mechanisms

This article explains how Redis removes expired keys using periodic and lazy deletion, describes the slave expiration handling, details the asynchronous memory reclamation commands like UNLINK and FLUSHALL ASYNC, and outlines the various maxmemory eviction policies including LRU, LFU, and their implementations.

CacheExpirationLFU
0 likes · 13 min read
Redis Expiration Strategies and Memory Eviction Mechanisms
Programmer DD
Programmer DD
Nov 3, 2019 · Backend Development

Master Java GC: Understand Memory, Parameters, and Algorithms for Interviews

This article explains Java garbage collection fundamentals, detailing JVM memory layout, key -X and -XX parameters, the mechanisms of object survival, and the main GC algorithms—Mark‑Sweep, Copying, Mark‑Compact, and generational collection—providing clear diagrams and interview‑ready insights.

GC AlgorithmsGarbage CollectionJVM
0 likes · 9 min read
Master Java GC: Understand Memory, Parameters, and Algorithms for Interviews
Programmer DD
Programmer DD
Nov 2, 2019 · Backend Development

Master JVM Memory Structure: A Deep Dive into Java’s Runtime Architecture

This article explains the Java Virtual Machine’s memory layout, covering the five runtime regions—heap, method area, JVM stacks, native method stacks, and program counter—along with their purposes, thread‑visibility, garbage‑collection behavior, and common pitfalls such as OutOfMemoryError and StackOverflowError.

Garbage CollectionJVMJava
0 likes · 9 min read
Master JVM Memory Structure: A Deep Dive into Java’s Runtime Architecture
Senior Brother's Insights
Senior Brother's Insights
Oct 18, 2019 · Fundamentals

Unlocking Java: A Deep Dive into JVM Memory Architecture

This article provides a comprehensive introduction to the Java Virtual Machine’s memory architecture, detailing the five runtime areas—Program Counter, JVM Stack, Native Method Stack, Heap, and Method Area—their thread scope, memory allocation, garbage‑collection behavior, and common errors such as OutOfMemoryError and StackOverflowError.

Garbage CollectionJVMJava
0 likes · 9 min read
Unlocking Java: A Deep Dive into JVM Memory Architecture
High Availability Architecture
High Availability Architecture
Oct 17, 2019 · Fundamentals

Memory Allocation vs. Pooling: Performance Analysis Across Java, G1, ZGC, and C++

This article investigates whether to allocate new memory for each incoming message or to reuse memory from a pool, analyzing the impact on throughput and latency in batch and soft‑real‑time applications, and presenting extensive benchmark results for various garbage collectors, JVM options, and native C++ implementations.

JavaMemory ManagementPooling
0 likes · 31 min read
Memory Allocation vs. Pooling: Performance Analysis Across Java, G1, ZGC, and C++
Aikesheng Open Source Community
Aikesheng Open Source Community
Oct 10, 2019 · Databases

Source Code Analysis of DBLE Memory Management Module

This article provides a detailed analysis of DBLE's memory management module, explaining its structure, configuration parameters, allocation and recycling logic, and includes annotated source code snippets for classes such as DirectByteBufferPool and ByteBufferPage, illustrating how off‑heap and on‑heap memory are handled.

ByteBufferDBLEJava
0 likes · 13 min read
Source Code Analysis of DBLE Memory Management Module
21CTO
21CTO
Oct 9, 2019 · Fundamentals

Mastering OOP in C: Implement the State Pattern with Real Code

This article walks you through applying object‑oriented concepts in C by implementing the State design pattern, covering class simulation with structs, inheritance via macros, lifecycle management, polymorphism, and a complete client example that demonstrates state transitions for a water model.

C#Memory ManagementObject-Oriented Programming
0 likes · 13 min read
Mastering OOP in C: Implement the State Pattern with Real Code
Programmer DD
Programmer DD
Sep 27, 2019 · Fundamentals

Why Does a Java Process Use Far More Memory Than Its Heap?

This article explains why a Java process consumes far more virtual memory than the configured heap size by detailing JVM subsystems, off‑heap allocations, native libraries, thread stacks, and other factors that contribute to overall memory usage.

JVMJavaMemory Management
0 likes · 7 min read
Why Does a Java Process Use Far More Memory Than Its Heap?
Programmer DD
Programmer DD
Sep 11, 2019 · Fundamentals

Why Java Strings Are Final and How Interning Affects Memory

This article explains the two ways to create Java strings, demonstrates how string literals are shared in the method area, shows the effect of the intern() method at runtime, and discusses why the String class is final, immutable, and thread‑safe.

JavaMemory ManagementString
0 likes · 8 min read
Why Java Strings Are Final and How Interning Affects Memory
MaGe Linux Operations
MaGe Linux Operations
Sep 7, 2019 · Fundamentals

How Linux Manages Memory: From Process Allocation to OOM and Cache

This article explores Linux kernel memory management, detailing process address space allocation, the behavior of the OOM killer, various memory mapping types (shared, private, anonymous), cache usage, manual and automatic memory reclamation, and related kernel parameters, providing practical insights and examples.

CacheMemory ManagementOOM
0 likes · 20 min read
How Linux Manages Memory: From Process Allocation to OOM and Cache
Ctrip Technology
Ctrip Technology
Aug 28, 2019 · Fundamentals

Java Memory Layout and Garbage Collection Principles

This article provides a comprehensive overview of the JVM runtime memory areas, explains how the JVM determines garbage objects, reviews major GC algorithms and collectors—including the latest ZGC—and offers practical code examples and command‑line instructions for reproducing various OutOfMemoryError scenarios.

Garbage CollectionJVMJava
0 likes · 29 min read
Java Memory Layout and Garbage Collection Principles
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 20, 2019 · Fundamentals

Why Java’s Garbage Collection Matters: Algorithms, Roots, and Memory Management

Java’s garbage collection, a critical yet often overlooked feature, encompasses various algorithms such as reference counting, reachability analysis, mark‑sweep, copying, and generational collection, each with distinct mechanisms, trade‑offs, and impacts on memory regions like Eden, Survivor, and Old spaces.

GC AlgorithmsGarbage CollectionJVM
0 likes · 15 min read
Why Java’s Garbage Collection Matters: Algorithms, Roots, and Memory Management
JavaEdge
JavaEdge
Aug 17, 2019 · Fundamentals

Why 640K Was Once “Enough” and How Modern Memory Management Solves It

From Bill Gates’s 640 KB claim to today’s multi‑gigabyte machines, this article explains how loaders map executable files, the evolution from segmentation to swapping and paging, and why virtual memory lets programs run with far less physical RAM despite performance trade‑offs.

Memory ManagementOperating SystemsPaging
0 likes · 12 min read
Why 640K Was Once “Enough” and How Modern Memory Management Solves It
Architect's Tech Stack
Architect's Tech Stack
Aug 1, 2019 · Fundamentals

Common Java OutOfMemoryError Types and Their Solutions

This article lists the most frequent Java OutOfMemoryError cases—including Java heap space, GC overhead limit exceeded, PermGen/Metaspace, native thread creation failures, array size limits, and direct buffer memory—explains their root causes, and provides practical troubleshooting steps and JVM tuning parameters to resolve them.

JVMMemory ManagementOutOfMemoryError
0 likes · 11 min read
Common Java OutOfMemoryError Types and Their Solutions
Node Underground
Node Underground
Jul 27, 2019 · Backend Development

Mastering Node.js Buffer: From Basics to Performance Optimization

This comprehensive guide explores Node.js Buffer fundamentals, binary data handling, stream integration, memory allocation mechanisms, practical usage scenarios, and performance benchmarks, providing developers with the knowledge to efficiently manage binary streams and boost application speed.

BufferMemory ManagementNode.js
0 likes · 21 min read
Mastering Node.js Buffer: From Basics to Performance Optimization
Programmer DD
Programmer DD
Jul 22, 2019 · Backend Development

Unlock Hidden JVM Memory: Track Native Allocations with NMT

This tutorial explains why Java applications often exceed their -Xmx limits, enumerates the main sources of native memory consumption in the JVM, and shows how to monitor and analyze these allocations using Native Memory Tracking (NMT) commands and flags.

JVMJavaMemory Management
0 likes · 13 min read
Unlock Hidden JVM Memory: Track Native Allocations with NMT
Java Backend Technology
Java Backend Technology
Jul 13, 2019 · Fundamentals

Why Java’s Garbage Collection Matters: From Roots to Generational Algorithms

This article explains Java garbage collection in depth, covering its definition, historical origins, reference‑counting and reachability algorithms, GC roots, memory regions such as Eden, Survivor and Old, and the main collection strategies like Mark‑Sweep, Copying, Mark‑Compact and Generational collection.

Garbage CollectionGenerational GCJVM
0 likes · 15 min read
Why Java’s Garbage Collection Matters: From Roots to Generational Algorithms
58 Tech
58 Tech
Jun 18, 2019 · Fundamentals

Understanding G1 Garbage Collector: Design, Algorithms, and Tuning Practices

This article explains the design principles, region-based architecture, object allocation strategies, Young and Mixed G1 GC phases, concurrent marking, three‑color marking, and practical tuning parameters for the G1 garbage collector in Java, illustrating concepts with code snippets and diagrams.

G1GCGarbage CollectionJVM
0 likes · 17 min read
Understanding G1 Garbage Collector: Design, Algorithms, and Tuning Practices
Big Data Technology & Architecture
Big Data Technology & Architecture
Jun 1, 2019 · Big Data

Understanding Spark Executor Memory Management: On‑Heap, Off‑Heap, and Unified Memory

This article explains Spark's executor memory architecture, covering on‑heap and off‑heap memory planning, static and unified memory managers, storage and execution memory allocation, RDD persistence, eviction policies, and shuffle memory usage, providing practical guidance for performance tuning.

Big DataExecutorMemory Management
0 likes · 23 min read
Understanding Spark Executor Memory Management: On‑Heap, Off‑Heap, and Unified Memory
Java Captain
Java Captain
May 27, 2019 · Fundamentals

Java Runtime Memory Areas, Object Creation, and Common Interview Questions

This article explains Java's runtime memory regions, including the program counter, stacks, heap, method area, constant pool, and direct memory, and details the HotSpot object creation process, memory layout, access mechanisms, as well as String and wrapper class behaviors, providing essential knowledge for Java interview preparation.

JVMJavaMemory Management
0 likes · 19 min read
Java Runtime Memory Areas, Object Creation, and Common Interview Questions
Xianyu Technology
Xianyu Technology
May 9, 2019 · Mobile Development

Investigation and Resolution of a Ghost Crash in Xianyu's Flutter Infrastructure

After a 2018 Flutter upgrade caused a mysterious “Ghost Crash” in Xianyu’s app, engineers traced an over‑released NSMutableArray in the accessibility bridge, fixed an illegal dealloc call, added proper checks for iOS Speak Screen, and eliminated the crash through a rapid gray‑scale rollout.

Memory Managementaccessibilitycrash-analysis
0 likes · 13 min read
Investigation and Resolution of a Ghost Crash in Xianyu's Flutter Infrastructure
Java Captain
Java Captain
May 3, 2019 · Fundamentals

Understanding the Composition of the Java Virtual Machine (JVM)

This article explains the overall architecture of the JVM, details each component of its runtime data area—including program counter, stacks, heap, and method area—and discusses related concepts such as the runtime constant pool and direct memory, providing a comprehensive overview for developers.

JVMJavaMemory Management
0 likes · 9 min read
Understanding the Composition of the Java Virtual Machine (JVM)
Big Data Technology Architecture
Big Data Technology Architecture
Apr 28, 2019 · Big Data

Apache Spark Memory Management: Storage and Execution Memory (Part 2)

This article continues the deep dive into Apache Spark memory management, explaining storage memory handling—including RDD persistence, caching, eviction, and disk spilling—as well as execution memory allocation for multi-tasking and shuffle operations, and detailing Spark’s internal structures such as BlockManager, StorageLevel, and Tungsten page management.

Apache SparkMemory ManagementRDD Persistence
0 likes · 13 min read
Apache Spark Memory Management: Storage and Execution Memory (Part 2)
360 Tech Engineering
360 Tech Engineering
Apr 25, 2019 · Mobile Development

Using Xcode’s Static Analyzer to Detect Localization, Logic, Memory, Data, and Syntax Issues in iOS Projects

This article explains how Xcode’s static analysis feature can automatically identify common iOS development problems—including localization warnings, logical errors, memory leaks, dead stores, and syntax mistakes—by analyzing code without execution, and shows how to resolve each type of issue.

Memory ManagementStatic AnalyzerXcode
0 likes · 5 min read
Using Xcode’s Static Analyzer to Detect Localization, Logic, Memory, Data, and Syntax Issues in iOS Projects
Didi Tech
Didi Tech
Apr 18, 2019 · Backend Development

Deep Dive into Go Slices: Creation, Internals, and Append Mechanics

The article explains Go slices as three‑field descriptors pointing to an underlying array, details creation methods, shows the low‑level runtime representation and assembly for make, describes how append triggers growslice with capacity‑doubling or ~25 % growth and alignment, and clarifies sharing, nil slices, and passing semantics.

AssemblyGoMemory Management
0 likes · 28 min read
Deep Dive into Go Slices: Creation, Internals, and Append Mechanics
360 Tech Engineering
360 Tech Engineering
Apr 11, 2019 · Mobile Development

Using Xcode’s Static Analyzer to Detect Localization, Logic, Memory, Data, and Syntax Issues in iOS Development

This article explains how Xcode’s static analysis feature can automatically identify text localization problems, logic errors, memory management concerns, dead‑store data issues, and syntax mistakes in iOS projects, and provides step‑by‑step instructions and code examples for fixing each type of warning.

Logic ErrorsMemory ManagementStatic Analyzer
0 likes · 5 min read
Using Xcode’s Static Analyzer to Detect Localization, Logic, Memory, Data, and Syntax Issues in iOS Development
ITPUB
ITPUB
Apr 10, 2019 · Backend Development

Top 45 Java Performance Tips Every Developer Should Follow

This guide presents 45 practical Java performance optimization techniques—ranging from proper use of singletons and final modifiers to efficient collection handling and avoiding costly operations—helping developers write faster, more memory‑efficient code.

JavaMemory ManagementPerformance Optimization
0 likes · 19 min read
Top 45 Java Performance Tips Every Developer Should Follow
Architect's Tech Stack
Architect's Tech Stack
Apr 1, 2019 · Databases

Comprehensive Guide to Common Redis Issues and Their Solutions

This article provides an in‑depth overview of why Redis is used, its drawbacks, the reasons behind its single‑threaded speed, data types and use‑cases, expiration policies, memory eviction strategies, consistency challenges with databases, and practical solutions for cache penetration, cache avalanche, and concurrent key competition.

CachingData ConsistencyMemory Management
0 likes · 15 min read
Comprehensive Guide to Common Redis Issues and Their Solutions
58 Tech
58 Tech
Mar 20, 2019 · Operations

JVM GC Tuning for Java Service Migration to a Private Cloud: A Multi‑Round Optimization Case Study

During the migration of a billion‑record Java service from physical servers to a private‑cloud Docker environment, a series of JVM GC tuning steps—including adaptive young generation sizing, larger young generation, reduced concurrent GC threads, and phantom‑reference cleanup—significantly reduced stop‑the‑world pauses and restored service performance.

Cloud MigrationGC TuningJVM
0 likes · 10 min read
JVM GC Tuning for Java Service Migration to a Private Cloud: A Multi‑Round Optimization Case Study
MaGe Linux Operations
MaGe Linux Operations
Mar 10, 2019 · Backend Development

Unlocking Redis Memory: Deep Dive into Its Internal Model and Optimization

This article explains Redis's memory model—including memory statistics, allocation, internal data structures like redisObject and SDS, object type encodings, and practical techniques for estimating usage, reducing fragmentation, and optimizing memory consumption—providing developers with actionable insights for high‑performance backend systems.

Backend DevelopmentMemory ManagementRedis
0 likes · 31 min read
Unlocking Redis Memory: Deep Dive into Its Internal Model and Optimization
21CTO
21CTO
Mar 3, 2019 · Fundamentals

Why Java Still Dominates: Multithreading, Memory Management, and Cross‑Platform Power

This article explains Java's enduring popularity by highlighting its write‑once‑run‑anywhere philosophy, built‑in multithreading, automatic memory management, scalability, cross‑platform capabilities, security features, and its strong presence in enterprise, IoT, mobile, and big‑data applications.

JavaMemory Managementmultithreading
0 likes · 8 min read
Why Java Still Dominates: Multithreading, Memory Management, and Cross‑Platform Power
Java Captain
Java Captain
Feb 23, 2019 · Databases

Redis Internal Data Structures and Object Implementations

This article provides a comprehensive overview of Redis, covering its core concepts, common use cases, and detailed explanations of internal objects such as redisObject, dictEntry, SDS, and the underlying data structures for String, List, Hash, Set, and ZSet, including code snippets and performance characteristics.

C ProgrammingIn-Memory DatabaseMemory Management
0 likes · 16 min read
Redis Internal Data Structures and Object Implementations
Meituan Technology Team
Meituan Technology Team
Feb 14, 2019 · Fundamentals

Understanding Java sun.misc.Unsafe: API, Usage, and Applications

The article explains Java’s sun.misc.Unsafe class, detailing how to safely obtain its singleton instance, describing its low‑level memory, CAS, thread, class, and object operations, and outlining common high‑performance use cases while warning about the significant risks of misuse.

JavaMemory ManagementUnsafe
0 likes · 19 min read
Understanding Java sun.misc.Unsafe: API, Usage, and Applications
Java Captain
Java Captain
Jan 28, 2019 · Fundamentals

Understanding ArrayList and LinkedList Internals During a Java Interview

The article recounts a Java interview where the interviewer explains the memory layout, random‑access capability, and time‑complexity differences between ArrayList (array‑based) and LinkedList (node‑based), using clear examples and code snippets to illustrate fundamental data‑structure concepts.

ArrayListJavaLinkedList
0 likes · 8 min read
Understanding ArrayList and LinkedList Internals During a Java Interview
MaGe Linux Operations
MaGe Linux Operations
Jan 22, 2019 · Fundamentals

Unlocking Linux: Core Components, Memory, Processes, and File Systems Explained

This article provides a comprehensive overview of Linux’s core architecture, detailing the kernel, memory management, process scheduling, file systems, VFS, device drivers, networking, shells, partitioning, mounting, and essential commands, offering readers a solid foundation for understanding and working with Linux systems.

File SystemLinuxMemory Management
0 likes · 33 min read
Unlocking Linux: Core Components, Memory, Processes, and File Systems Explained
MaGe Linux Operations
MaGe Linux Operations
Jan 18, 2019 · Fundamentals

Unlock Linux Memory: From Address Spaces to Allocation Algorithms

This article provides a comprehensive guide to Linux memory management, covering memory organization, address spaces, MMU translation, allocation algorithms such as the buddy system and slab allocator, usage scenarios, common pitfalls, and practical tools for monitoring and debugging memory usage.

Allocation AlgorithmsLinuxMemory Management
0 likes · 19 min read
Unlock Linux Memory: From Address Spaces to Allocation Algorithms
JD Tech
JD Tech
Jan 11, 2019 · Big Data

Spark Memory Management and Tuning Practices for Large-Scale Billing Systems

This article explains how Spark's memory management models and configuration parameters can be tuned to handle massive billing data efficiently, covering StaticMemoryManager vs UnifiedMemoryManager, storage and shuffle memory fractions, common OOM and file‑not‑found issues, and practical performance‑optimisation tips.

Distributed ComputingMemory ManagementPerformance Tuning
0 likes · 9 min read
Spark Memory Management and Tuning Practices for Large-Scale Billing Systems
dbaplus Community
dbaplus Community
Jan 6, 2019 · Databases

Inside Redis: How Memory Structures and Encoding Power Its 5 Data Types

This article explains how Redis stores and encodes its five data types by using various in‑memory data structures such as SDS strings, linked lists, quicklists, hash tables, skip‑lists, intsets and zip‑lists, and it also covers object mapping, expiration policies, LRU eviction, and the RDB/AOF persistence mechanisms.

Data StructuresMemory ManagementPersistence
0 likes · 25 min read
Inside Redis: How Memory Structures and Encoding Power Its 5 Data Types
ITPUB
ITPUB
Dec 28, 2018 · Fundamentals

Unlocking Linux Memory: Architecture, Allocation Algorithms, and Common Pitfalls

This comprehensive guide explores Linux memory architecture, address spaces, allocation algorithms like the buddy system and slab allocator, DMA handling, user‑space allocation functions, and practical pitfalls, providing developers with essential insights to optimize performance and avoid common errors.

DMALinuxMemory Management
0 likes · 20 min read
Unlocking Linux Memory: Architecture, Allocation Algorithms, and Common Pitfalls
Efficient Ops
Efficient Ops
Dec 27, 2018 · Fundamentals

Why Python Lists Aren’t Pre‑Allocated: Inside CPython’s Memory Management

Python’s list type appears flexible, but its underlying CPython implementation uses a dynamic resizing strategy without a pre‑allocated memory pool, allocating memory on demand via list_resize and PyMem_RESIZE, which this article explains through code analysis, memory size measurements, and practical recommendations.

CPythonListMemory Management
0 likes · 13 min read
Why Python Lists Aren’t Pre‑Allocated: Inside CPython’s Memory Management
Java Captain
Java Captain
Dec 17, 2018 · Fundamentals

Understanding Java Heap and Stack Memory with Examples

This article explains the differences between Java heap and stack memory, their advantages and disadvantages, and demonstrates how string objects are stored and shared using code examples that illustrate memory allocation and reference behavior.

Garbage CollectionJavaMemory Management
0 likes · 4 min read
Understanding Java Heap and Stack Memory with Examples
Java Backend Technology
Java Backend Technology
Dec 14, 2018 · Fundamentals

Why Does Your JVM Keep Objects Alive After Method Returns? A Memory & GC Deep Dive

This article investigates why objects allocated in a Java method are not immediately reclaimed after the method exits, demonstrating through experiments how JVM heap regions, especially the Eden space, influence garbage collection timing, and provides practical steps to control memory and CPU usage by deliberately allocating small and large objects.

Garbage CollectionJVMJava
0 likes · 8 min read
Why Does Your JVM Keep Objects Alive After Method Returns? A Memory & GC Deep Dive
Meituan Technology Team
Meituan Technology Team
Nov 1, 2018 · Mobile Development

Understanding Swift Performance: Allocation, Reference Counting, and Dispatch

Swift performance hinges on allocation choices, ARC overhead, and method dispatch, so using stack‑allocated structs instead of heap‑allocated classes, applying final or private to force static dispatch, leveraging protocol‑oriented containers, specializing generics, and enabling whole‑module optimization together yield faster, more efficient iOS code.

DispatchMemory ManagementProtocol Oriented
0 likes · 26 min read
Understanding Swift Performance: Allocation, Reference Counting, and Dispatch
MaGe Linux Operations
MaGe Linux Operations
Sep 7, 2018 · Operations

Why Linux ‘Ate My RAM’: Understanding free, buffers, and cache

Linux appears to consume most of a system’s RAM, but the free command’s output, including buffers and cache, actually reflects memory used for performance optimization; this article explains the distinction, how to interpret free’s columns, and demonstrates the impact with a 1 GB file read experiment.

BuffersCacheLinux
0 likes · 7 min read
Why Linux ‘Ate My RAM’: Understanding free, buffers, and cache
MaGe Linux Operations
MaGe Linux Operations
Aug 26, 2018 · Fundamentals

What Is Python? 25 Essential Q&A for Beginners

This article provides a comprehensive overview of Python, covering its nature as an interpreted, interactive, object‑oriented language, key benefits, coding conventions, memory management, debugging tools, core concepts like decorators, data structures, namespaces, lambda functions, testing, and many practical programming details for newcomers.

Data StructuresMemory ManagementProgramming Fundamentals
0 likes · 10 min read
What Is Python? 25 Essential Q&A for Beginners
21CTO
21CTO
Aug 1, 2018 · Fundamentals

Why Virtual Memory and Paging Make Your Computer Faster and Safer

This article explains how memory serves as the main storage for processes, introduces the concepts of virtual memory and paging, and describes how page tables and multi‑level paging enable efficient address translation, isolation, and sharing in modern operating systems.

Memory ManagementPagingVirtual Memory
0 likes · 12 min read
Why Virtual Memory and Paging Make Your Computer Faster and Safer
MaGe Linux Operations
MaGe Linux Operations
Jul 31, 2018 · Fundamentals

Understanding Memory, Virtual Memory, and Paging in Linux

This article explains how computer memory works, covering physical memory characteristics, address spaces, RAM's random access nature, virtual memory translation, paging mechanisms, page size queries, and multi‑level page tables that enable efficient and secure memory management in Linux.

LinuxMemory ManagementPaging
0 likes · 13 min read
Understanding Memory, Virtual Memory, and Paging in Linux
Meituan Technology Team
Meituan Technology Team
Jul 26, 2018 · Databases

Understanding and Optimizing Redis Rehash Mechanism and Scan Behavior

The article details how Redis’s incremental rehashing can double memory usage and trigger massive key eviction and scan inconsistencies in large‑scale clusters, explains the underlying dictionary structures, demonstrates the cursor bug when tables shrink, and presents a memory‑guard and scan‑cursor patch that resolves both problems.

C#Memory ManagementRedis
0 likes · 26 min read
Understanding and Optimizing Redis Rehash Mechanism and Scan Behavior