Tagged articles
heap memory
14 articles · Page 1 of 1
The article explains that stack memory allocation is quicker than heap allocation because the stack uses a simple pointer move and LIFO order, while the heap must search for free blocks, manage fragmentation, and often requires explicit deallocation, leading to higher overhead and potential leaks.
C++Interviewheap memory
0 likes · 65 min read

A production outage at 3 am revealed a 10‑second Full GC pause on an 8 GB heap; the article walks through evidence collection, heap‑size rebalancing, switching to G1, fine‑tuning G1 parameters, and code changes that together reduced Full GC pauses to 200 ms and improved latency dramatically.
Full GCG1 GCGC tuning
0 likes · 12 min read

Node.js 25.9.0 adds support for the --max‑heap‑size flag in the NODE_OPTIONS whitelist, allowing containers on Kubernetes to set heap limits via environment variables, reducing OOM kills, while also introducing experimental stream/iter API, test‑module mock changes, new Web Crypto algorithms, and other enhancements.
KubernetesNode.jsStream API
0 likes · 8 min read

This comprehensive guide explores Linux process heap memory layout, the inner workings of malloc and ptmalloc, common pitfalls like leaks, fragmentation and holes, and equips developers with practical tools and optimization techniques to diagnose and improve heap performance.
Linuxheap memoryptmalloc
0 likes · 76 min read

This article explains the fundamental differences between stack and heap memory allocation, covering their allocation mechanisms, performance characteristics, typical use cases such as stack overflow and memory leaks, and provides C and C++ code examples to illustrate each concept.
C++Memory Leakheap memory
0 likes · 60 min read

This article provides a comprehensive overview of glibc's heap memory management, explaining the role of brk and mmap, the organization of arenas, heaps, chunks, bin structures, allocation and deallocation strategies, and how these concepts are applied in security research and exploit development.
C++freeglibc
0 likes · 29 min read

This article explains how the Linux kernel implements heap memory management, covering the heap data structure, the mm_struct fields start_brk and brk, the brk/sbrk and malloc/free allocation methods, the brk and mmap system calls, and the internal glibc structures heap_info and malloc_state that track heap state.
Linuxbrkheap memory
0 likes · 17 min read

This article explains Java heap memory concepts, garbage collection mechanisms, common memory issues, and outlines the team's quality assurance framework, including testing left‑shift with AI code review and right‑shift monitoring to improve reliability and performance.
garbage collectionheap memoryperformance
0 likes · 11 min read

This article explains Java heap memory concepts, garbage collection, common memory issues like leaks and OutOfMemoryError, and outlines the team's quality assurance framework—including left‑shift code review, right‑shift monitoring, and continuous delivery practices—to help prevent and resolve production alerts.
JavaOutOfMemoryErrorgarbage collection
0 likes · 10 min read

This article explains why JVM memory tuning is essential for high‑pay roles, outlines six practical steps—including GC monitoring, heap dump generation, analysis, and parameter adjustments—and provides detailed guidance on heap size, generation ratios, GC types, and thread stack settings to reduce Full GC frequency and improve application performance.
BackendFull GCJVM
0 likes · 7 min read

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.
JavaScriptconstgarbage collection
0 likes · 5 min read

This article explores the inner workings of Linux's glibc malloc, detailing how heap memory is requested from the kernel, how multithreaded support is implemented with per‑thread arenas, and the structures such as arenas, bins, and chunks that together determine allocation efficiency.
LinuxMemory AllocatorMultithreading
0 likes · 26 min read

This article uses the Chinese Spring Festival story to explain Java's heap structure, young and old generations, large‑object allocation, and how excessive memory consumption leads to heap‑space OOM and stop‑the‑world garbage collection, providing code examples and practical mitigation tips.
JVMJavaOOM
0 likes · 7 min read

This article narrates a step‑by‑step investigation of a Java server whose heap memory exceeded 95%, detailing log collection, tool usage, thread analysis, and ultimately uncovering a thread‑unsafe SimpleDateFormat that caused an infinite loop and massive memory consumption.
JavaSimpleDateFormatheap memory
0 likes · 15 min read
