The article explains segment‑paging memory management by comparing pure paging, pure segmentation, and their combination, detailing address translation, two‑level page tables, Linux implementation, and practical scenarios such as process layout inspection, fragmentation handling, and protection mechanisms.
The article explains the Open‑Closed Principle, shows how Spring leaves empty hook methods like onRefresh() for extensions, demonstrates the concept with a Java demo, compares inheritance‑based and interface‑based extension approaches, and discusses trade‑offs and practical guidelines for designing extension points.
This tutorial explains the FIFO principle of queues with everyday analogies, compares stacks and queues, lists core operations, provides a full Python implementation, demonstrates real‑world scenarios like server requests and printer jobs, and highlights common beginner pitfalls.
This article introduces the stack data structure, explains its LIFO principle with everyday analogies like browser back and undo, compares it to arrays and linked lists, provides a complete Python implementation, demonstrates a simple undo simulation, and highlights common pitfalls for beginners.
This article explains segmented memory management, contrasting it with paging, detailing segment types, segment tables, address translation, protection mechanisms, dynamic growth, advantages, drawbacks, and how modern systems combine segmentation with paging for efficient virtual memory handling.
The article explains why modern 64‑bit Windows stores its native binaries in the folder named System32 while the seemingly opposite‑named SysWOW64 actually contains the legacy 32‑bit files, tracing the history from Windows 3.1 through Windows 95/NT to the file‑system redirection mechanism that lets both 32‑ and 64‑bit programs run without code changes.
The article demonstrates that although List.of, Arrays.asList, and unmodifiableList implement the List interface, they violate the Liskov Substitution Principle because their optional add/remove operations throw UnsupportedOperationException, revealing a hidden contract mismatch between interface documentation and runtime behavior.
The article explains paging as a memory‑management technique that divides physical memory into fixed‑size pages, maps virtual pages to page frames via page tables, uses multi‑level tables and a TLB for speed, and discusses its advantages, drawbacks, and practical workflow.
This tutorial explains linked lists with a vivid array‑vs‑list analogy, outlines their core structure, shows real‑world scenarios, provides fully commented Python code with sample output, and highlights common pitfalls and a quick decision guide for choosing between arrays and linked lists.
This extensive article explains Linux memory management fundamentals, covering physical and virtual memory, allocation and release mechanisms, key kernel functions, performance tuning, leak detection, fragmentation handling, and real‑world code samples for developers and system engineers.
The article explains how JDK 17’s java.time.LocalDate follows the Single Responsibility Principle by separating date data from formatting, contrasts this design with the older mutable java.util.Date, and shows how to spot classes that take on too many responsibilities.
The article explains how operating systems use virtual memory to extend physical RAM with disk space, covering concepts like paging, page tables, multi‑level tables, swap space, replacement algorithms (LRU, FIFO, LFU), and practical Python and JVM examples.
The author argues that well‑written, regularly maintained code comments explain design decisions, make future modifications safer, and therefore serve as an effective tool for lowering technical debt, despite common claims that clean code alone eliminates the need for comments.
The article explains how the Linux Deadline real‑time scheduler works, detailing its three core parameters (runtime, period, deadline), the EDF algorithm, kernel data structures, CBS bandwidth control, task state transitions, common configuration pitfalls, and practical tuning and monitoring commands.
This article explains arrays using a locker analogy, outlines their core characteristics and typical use cases, provides a complete Python example for basic operations with output, and highlights common beginner pitfalls such as zero‑based indexing and fixed length.
The article explains how cache hit rate directly impacts program speed, describes the three hit‑rate levels, factors such as data locality, working‑set size and associativity, types of cache misses, and provides practical techniques—data alignment, array traversal, packing, prefetching, and monitoring tools—to improve performance.
FFmpeg 9.0, codenamed “Lei,” was released on August 4 to commemorate Chinese audio‑video developer Lei Xiaohua, whose contributions to the library and early AI‑related tutorials shaped the ecosystem, while the article also traces FFmpeg’s history, naming conventions, and expanding role in modern AI pipelines.
This article uses a milk‑tea shop analogy and Java code examples to clearly illustrate the three core OOP concepts—encapsulation, inheritance, and polymorphism—showing how they solve data safety, code reuse, and flexible extension while highlighting common pitfalls.
Java 27 enables Compact Object Headers, shrinking the default 64‑bit object header from 12 bytes to 8 bytes, which can noticeably lower heap usage for object‑heavy services; the article explains the layout change, demonstrates it with JOL, and offers practical testing guidance for real‑world applications.
The article defines a time slice (time quantum) as the fixed CPU interval allocated to each ready process in a time‑sharing scheduler, explains its role in round‑robin and CFS algorithms, discusses size trade‑offs, Linux implementation details, context‑switch costs, and typical interview follow‑up questions.
