BestHub
Sign in
Tagged articles
960 articles
Page 8 of 10
IT Architects Alliance
IT Architects Alliance
Oct 5, 2020 · Fundamentals

Understanding Linux: Kernel, Shell, Filesystem and Core Components Explained

This comprehensive guide breaks down the four main parts of a Linux system—kernel, shell, filesystem and applications—detailing kernel subsystems such as memory and process management, shell variants, file types, directory hierarchy, partition handling, VFS, mounting procedures, link types and essential command‑line tools, while also touching on application bundles and kernel parameter tuning.

FilesystemLinuxMount
0 likes · 35 min read
Understanding Linux: Kernel, Shell, Filesystem and Core Components Explained
Programmer DD
Programmer DD
Sep 20, 2020 · Operations

Why Is Your Redis Slowing Down? 7 Common Latency Culprits and How to Fix Them

This article examines typical Redis latency spikes—such as complex O(n) commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—explaining how to detect, monitor, and mitigate each issue to maintain high‑performance operation.

AOFLatencyPerformance tuning
0 likes · 17 min read
Why Is Your Redis Slowing Down? 7 Common Latency Culprits and How to Fix Them
ITPUB
ITPUB
Sep 11, 2020 · Fundamentals

How Redis Implements Binary‑Safe Strings with Simple Dynamic Strings (SDS)

This article explains the design and evolution of Redis's Simple Dynamic Strings (SDS), covering the original pre‑3.2 structure, the newer type‑specific headers, the core API functions for creating, clearing, and concatenating SDS objects, and the memory‑reallocation strategy that ensures binary safety and efficient storage.

Binary SafetyC++Data Structures
0 likes · 13 min read
How Redis Implements Binary‑Safe Strings with Simple Dynamic Strings (SDS)
Architecture Digest
Architecture Digest
Sep 3, 2020 · Databases

Practical Elasticsearch Performance and Stability Tuning Guide

This article consolidates practical Elasticsearch tuning techniques—including configuration file adjustments, system‑level optimizations, and usage‑level settings—to improve cluster performance, stability, and resource efficiency for production environments.

Big DataCluster ConfigurationElasticsearch
0 likes · 15 min read
Practical Elasticsearch Performance and Stability Tuning Guide
vivo Internet Technology
vivo Internet Technology
Aug 19, 2020 · Mobile Development

Why Android Images Cause OOM: Memory Usage, DPI, and Glide Tips

This article explains how different Android versions handle image memory, clarifies screen size, density, and resolution concepts, shows how folder placement and bitmap formats affect RAM usage, and provides practical Glide configuration to prevent out‑of‑memory crashes.

AndroidGlideImage Loading
0 likes · 11 min read
Why Android Images Cause OOM: Memory Usage, DPI, and Glide Tips
Architect's Tech Stack
Architect's Tech Stack
Aug 18, 2020 · Databases

Understanding Redis Memory Limits and Eviction Policies

This article explains how to configure Redis's maximum memory usage, describes the built‑in eviction strategies such as noeviction, allkeys‑lru, volatile‑lru, random and ttl policies, shows how to query and set these policies via configuration files or runtime commands, and details the LRU and LFU algorithms used by Redis, including Java sample code and recent improvements in Redis 3.0 and 4.0.

LFULRURedis
0 likes · 9 min read
Understanding Redis Memory Limits and Eviction Policies
Wukong Talks Architecture
Wukong Talks Architecture
Aug 7, 2020 · Fundamentals

JVM Interview Questions and Java Mind Map Resources

This article presents a comprehensive collection of JVM interview questions covering memory areas, garbage collection, class loading, and performance tuning, along with eleven detailed Java mind‑map images that visually summarize core concepts such as the JVM architecture, GC algorithms, and thread management.

Garbage CollectionInterviewJVM
0 likes · 8 min read
JVM Interview Questions and Java Mind Map Resources
Programmer DD
Programmer DD
Jul 26, 2020 · Databases

Mastering Redis Memory Limits and Eviction Policies: Config, LRU, LFU Explained

Redis, an in‑memory key‑value store, lets you set a maximum memory limit via configuration files or runtime commands, choose among various eviction strategies such as noeviction, allkeys‑lru, volatile‑lru, and LFU, and understand how approximate LRU works, with Java code examples illustrating these concepts.

LFULRURedis
0 likes · 10 min read
Mastering Redis Memory Limits and Eviction Policies: Config, LRU, LFU Explained
MaGe Linux Operations
MaGe Linux Operations
Jul 16, 2020 · Databases

Master Redis Memory Limits and Eviction Policies: Config, LRU, LFU Explained

This article explains how to configure Redis's maximum memory usage, modify memory limits at runtime, understand the built‑in eviction strategies—including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, and volatile‑ttl—how to query and set these policies, and the details of LRU and LFU algorithms with Java examples and performance comparisons.

LFULRURedis
0 likes · 10 min read
Master Redis Memory Limits and Eviction Policies: Config, LRU, LFU Explained
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 10, 2020 · Fundamentals

Common Java OutOfMemoryError Types and Their Solutions

This article explains the various OutOfMemoryError variants in the Java Virtual Machine, illustrates each with reproducible code examples, analyzes root causes, and provides practical mitigation strategies such as JVM flags, code refactoring, and system‑level adjustments.

JVMJavaOutOfMemoryError
0 likes · 20 min read
Common Java OutOfMemoryError Types and Their Solutions
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 5, 2020 · Fundamentals

Understanding JVM Runtime Data Areas and Memory Management

This article provides a comprehensive overview of the Java Virtual Machine's runtime data areas—including the program counter, JVM stack, native method stack, heap, and method area—explaining their structures, lifecycles, related JVM flags, garbage‑collection strategies, TLAB, and escape‑analysis optimizations.

Garbage CollectionJVMJava
0 likes · 42 min read
Understanding JVM Runtime Data Areas and Memory Management
Open Source Linux
Open Source Linux
Jul 3, 2020 · Fundamentals

Unlock Linux Memory: From Basics to Advanced Allocation Strategies

This comprehensive guide explores Linux memory fundamentals, address space layout, fragmentation, buddy and slab allocation algorithms, kernel and user‑space memory pools, DMA handling, common pitfalls in C/C++ memory management, and practical commands for monitoring and debugging memory usage on Linux systems.

Allocation AlgorithmsLinuxkernel
0 likes · 23 min read
Unlock Linux Memory: From Basics to Advanced Allocation Strategies
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 30, 2020 · Fundamentals

Understanding Java Garbage Collection: Goals, Algorithms, and Timing

This article explains Java garbage collection by outlining its purpose, the criteria for reclaimable objects through reference counting and reachability analysis, when collection occurs, and the main GC algorithms—including mark‑sweep, copying, mark‑compact, and generational collection—along with common JVM collectors.

GC AlgorithmsGarbage CollectionJVM
0 likes · 9 min read
Understanding Java Garbage Collection: Goals, Algorithms, and Timing
ITPUB
ITPUB
Jun 18, 2020 · Fundamentals

Mastering Linux Memory Management: From Address Space to Allocation Algorithms

This article provides a comprehensive guide to Linux memory management, covering the memory organization, address spaces, fragmentation causes and mitigation, the buddy and slab allocation algorithms, kernel and user‑space memory pools, common pitfalls, and practical tools for monitoring and debugging memory usage.

LinuxSlab AllocatorUser Space
0 likes · 20 min read
Mastering Linux Memory Management: From Address Space to Allocation Algorithms
Laravel Tech Community
Laravel Tech Community
Jun 16, 2020 · Mobile Development

Kuaishou’s APM Platform and Mobile Performance Optimization: Insights from Yang Kai

In a mobile‑first world where limited device resources and unstable networks threaten user retention, Kuaishou’s performance team built an APM monitoring platform and applied systematic memory, startup, and jank optimizations that cut startup time by 40%, reduced package size by 23 MB, and significantly improved key product metrics.

APMKuaishouPerformance Optimization
0 likes · 9 min read
Kuaishou’s APM Platform and Mobile Performance Optimization: Insights from Yang Kai
Python Programming Learning Circle
Python Programming Learning Circle
Jun 3, 2020 · Fundamentals

Understanding CPython's Memory Management (Python 2.7)

This article explains how CPython implements its own memory‑management scheme—including the layered allocation model, pool and arena structures, block size classes, and reference‑count‑based reclamation—by dissecting the source code of Python 2.7’s obmalloc module.

CPythonGarbage CollectionObmalloc
0 likes · 23 min read
Understanding CPython's Memory Management (Python 2.7)
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 25, 2020 · Databases

Mastering Redis: Expiration Strategies, Memory Management, and Transactions

This guide explores Redis key expiration policies—including active, lazy, and periodic expiration—memory eviction strategies, resource consumption, thread model, and transaction mechanisms, providing practical insights on configuring TTL, optimizing memory usage, and understanding Redis’s single‑threaded architecture for reliable data handling.

ExpirationRedisThread Model
0 likes · 12 min read
Mastering Redis: Expiration Strategies, Memory Management, and Transactions
Selected Java Interview Questions
Selected Java Interview Questions
May 21, 2020 · Databases

Redis Memory Limits, Eviction Policies, and LRU/LFU Implementation

This article explains how to configure Redis's maximum memory usage, describes the various eviction strategies including noeviction, allkeys‑lru, volatile‑lru, random and ttl policies, shows how to query and set these policies via configuration files or commands, and provides Java code for a simple LRU cache while discussing Redis's approximate LRU and LFU algorithms.

JavaLFULRU
0 likes · 15 min read
Redis Memory Limits, Eviction Policies, and LRU/LFU Implementation
Java Captain
Java Captain
May 20, 2020 · Fundamentals

Why Setting Unused Objects to null May Not Help Java Garbage Collection

This article explains, with concrete Java examples and JVM runtime‑stack analysis, why manually assigning null to objects that are out of scope does not always trigger earlier garbage collection, and how stack slot reuse can achieve the same effect without relying on a questionable practice.

Garbage CollectionJVMJava
0 likes · 8 min read
Why Setting Unused Objects to null May Not Help Java Garbage Collection
Open Source Linux
Open Source Linux
May 19, 2020 · Fundamentals

Essential Operating System Concepts Every Developer Should Know

This comprehensive guide explains over 190 fundamental operating system and computer architecture concepts—including OS kernels, memory management, process control, virtualization, storage, networking, and security—providing clear definitions, examples, and visual illustrations to help readers grasp the core building blocks of modern computing systems.

Computer Architecturekernelmemory management
0 likes · 45 min read
Essential Operating System Concepts Every Developer Should Know
macrozheng
macrozheng
Apr 22, 2020 · Databases

13 Proven Techniques to Supercharge Redis Performance

Learn how to dramatically boost Redis speed by shortening key/value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, pipelines, avoiding mass expirations, optimizing clients, limiting memory, running on physical servers, tweaking persistence, disabling THP, and adopting distributed architectures.

CachingDatabaseLazy Free
0 likes · 19 min read
13 Proven Techniques to Supercharge Redis Performance
Python Programming Learning Circle
Python Programming Learning Circle
Apr 21, 2020 · Fundamentals

9 Common Python Interview Questions and Answers

This article presents nine frequently asked Python interview questions covering lists, tuples, dictionaries, string reversal, memory management, session/cookie/token concepts, HTTP methods, decorators, concurrency, comprehensions, and generators, each explained with clear descriptions and code examples for developers preparing for technical interviews.

Data StructuresGeneratorsInterview
0 likes · 11 min read
9 Common Python Interview Questions and Answers
Java Architect Essentials
Java Architect Essentials
Apr 17, 2020 · Fundamentals

Comprehensive Java JVM Interview Guide: Architecture, Memory, GC, Class Loading, and Optimization

This article provides an extensive overview of Java Virtual Machine fundamentals for interview preparation, covering JVM components, runtime data areas, heap vs. stack memory, garbage collection mechanisms, algorithms, collectors, memory allocation strategies, class loading processes, and tuning tools.

Garbage CollectionJVMPerformance tuning
0 likes · 31 min read
Comprehensive Java JVM Interview Guide: Architecture, Memory, GC, Class Loading, and Optimization
Sohu Tech Products
Sohu Tech Products
Apr 8, 2020 · Fundamentals

Design and Implementation of Go's Garbage Collector

This article provides an in‑depth overview of Go's garbage collector, covering its design principles, mark‑sweep algorithm, tri‑color abstraction, write‑barrier techniques, incremental and concurrent collection, evolution across Go versions, and detailed implementation details of marking, sweeping, and memory reclamation.

Garbage Collectionmemory management
0 likes · 52 min read
Design and Implementation of Go's Garbage Collector
Java Backend Technology
Java Backend Technology
Apr 7, 2020 · Databases

How to Inspect and Clear Linux Buff/Cache and Optimize MySQL Joins

This article explains how to use Linux commands like free and sync to view and clear buffer/cache memory, describes the information shown by free, and then dives into SQL join types, their performance impact, and optimization techniques such as indexing, join_buffer tuning, and join algorithms.

Buffer CacheLinuxMySQL
0 likes · 9 min read
How to Inspect and Clear Linux Buff/Cache and Optimize MySQL Joins
FunTester
FunTester
Apr 3, 2020 · Fundamentals

JVM Memory Model, GC Log Analysis, and Production Parameter Optimization

This article examines production JVM memory architecture, explains GC log generation and analysis, details the ParNew + CMS collector behavior, and provides practical parameter tuning recommendations to optimize heap size, young generation, and garbage collection for stable Java applications in production environments.

Garbage CollectionJVMJava
0 likes · 10 min read
JVM Memory Model, GC Log Analysis, and Production Parameter Optimization
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 2, 2020 · Fundamentals

Fundamental Concepts of Operating Systems and Computer Architecture

This article provides a comprehensive overview of operating system fundamentals and computer architecture, covering topics such as OS components, kernel and user modes, memory management, process handling, hardware interfaces, storage hierarchies, virtualization, and related historical and modern systems in roughly eighty concise entries.

Computer Architectureinterrupt()kernel
0 likes · 25 min read
Fundamental Concepts of Operating Systems and Computer Architecture
FunTester
FunTester
Apr 1, 2020 · Backend Development

Mastering JVM Performance: 6 Essential Parameters and GC Tuning Tips

Learn how to optimize Java applications by configuring six critical JVM parameters—including heap size, Metaspace limits, GC algorithm selection, logging, heap dumps, thread stack size, and network timeouts—while understanding their impact on performance, memory usage, and troubleshooting common out‑of‑memory issues.

Garbage CollectionHeap DumpJVM
0 likes · 9 min read
Mastering JVM Performance: 6 Essential Parameters and GC Tuning Tips
Senior Brother's Insights
Senior Brother's Insights
Mar 31, 2020 · Databases

Boost Redis Performance: 13 Proven Optimization Techniques

Learn how to dramatically improve Redis performance by shortening key-value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, leveraging pipeline, preventing mass expirations, optimizing client connections, limiting memory, running on physical servers, configuring persistence, disabling THP, and adopting distributed architectures.

Database TuningLazy FreePerformance Optimization
0 likes · 18 min read
Boost Redis Performance: 13 Proven Optimization Techniques
Python Programming Learning Circle
Python Programming Learning Circle
Mar 27, 2020 · Fundamentals

Understanding Python Memory Management: Reference Counting, Circular References, and Generational Garbage Collection

Python abstracts memory management through reference counting, handles cyclic references with a generational garbage collector, and employs the weak generational hypothesis to efficiently reclaim objects, as illustrated by code examples demonstrating object creation, deletion, and the behavior of different GC generations.

Garbage CollectionGenerational GCmemory management
0 likes · 8 min read
Understanding Python Memory Management: Reference Counting, Circular References, and Generational Garbage Collection
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 StructuresRedisSDS
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
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.

OS ArchitectureSystem Callsfile system
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 DatabaseRedis
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.

GCDObjective‑CUIKit
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 StructuresGeneratorsInterview
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.

JVMJavaOutOfMemoryError
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 StructuresRedis
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.

PageTablesRSSSLAB
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 CollectionHeapJVM
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.

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

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

LinksMountfile system
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 PoolJavaString
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.

ARCProperty ModifiersRetain Cycle
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-WriteLinuxSystem Calls
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 CollectionInterview Preparation
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.

JavaPoolingallocation
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++Design PatternsPolymorphism
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.

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

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

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

G1Garbage CollectionJVM
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