Various techniques for deliberately creating memory leaks in Java are presented, including using long‑running threads with custom class loaders, static references, ThreadLocal misuse, improper handling of resources like connections and streams, and flawed implementations of hashCode/equals, each illustrated with code examples.
This article presents a non‑intrusive, high‑performance engine that adds secondary multi‑column indexes to Apache HBase, enabling efficient complex condition queries while preserving HBase's scalability, and details its principles, architecture, query API, index configuration, and practical trade‑offs.
This article explains how to build a Java event‑notification system using the observer pattern, highlights typical mistakes such as concurrent modification and deadlocks, and presents several thread‑safe implementations ranging from synchronized blocks to CopyOnWriteArraySet and atomic primitives.
This article explains the backtracking algorithm as an enumeration‑like depth‑first search technique, outlines its fundamental concepts, basic ideas, typical problem‑solving steps, and provides both non‑recursive and recursive pseudo‑code frameworks for implementation.
This article provides a concise introduction to CPU cache hierarchies, read/write policies, cache coherency protocols such as snooping and MESI, and the impact of different memory models on multi‑core systems, helping developers grasp essential hardware concepts for reliable software design.
This article explains the fundamental concepts of greedy algorithms, outlines their basic design steps, discusses the conditions under which they yield optimal solutions, presents an implementation framework, and analyzes a knapsack problem example that illustrates common greedy strategies and their limitations.
The article chronicles Zhihu's growth from a two‑engineer startup using Python and Tornado on a single Linode server to a large‑scale backend employing high‑availability MySQL, Redis sharding, a custom distributed logging system (Kids), event‑driven processing with Sink and Beanstalkd, component‑based page rendering via ZhihuNode, and a multi‑layer SOA built on evolving RPC frameworks.
This article examines why Python’s execution speed can lag behind compiled languages and presents five practical approaches—using alternative runtimes like PyPy, JIT‑based implementations such as Pyston, compilation tools like Nuitka, C extensions via Cython, and JIT acceleration with Numba—to improve Python performance.
This article explains the fundamentals of dynamic programming, covering its basic concepts, underlying ideas, applicable problem properties, step‑by‑step solution methodology, implementation considerations, and provides a concise pseudo‑code framework to illustrate the algorithmic process.
This guide walks you through obtaining the Linux kernel source, extracting it, configuring options with menuconfig, compiling with make, installing modules and the kernel, updating bootloader entries, and cleaning up, providing practical commands and tips for a successful custom kernel build.
This guide explains how to delete a static DHCP binding on Huawei's GigabitEthernet 0/0/2 interface, troubleshoot the "static‑MAC user" error, and verify the removal using CLI commands such as undo, reset, and display.
The Poppen.de social site demonstrates a highly scalable backend architecture that combines Nginx, PHP‑FPM, MySQL, Memcached, RabbitMQ, CouchDB, Graphite, Red5 and Tsung to handle millions of users, high concurrency, and extensive media traffic while maintaining performance and reliability.
This article explains the divide-and-conquer algorithmic technique, covering its basic concepts, design strategy, three-step recursive process, complexity analysis, and a list of classic problems that can be efficiently solved using this method.
This guide walks through creating VLANs 2, 20, and 30, configuring VLANIF interfaces with IP addresses, setting up PC access ports, establishing a trunk link to the router, and adding a default static route to complete the router configuration.
This article explores why Python’s execution speed lags behind compiled languages, presents two main optimization strategies, and details five practical approaches—including PyPy, Pyston, Nuitka, Cython, and Numba—to significantly improve Python performance on the same hardware.
This article examines common NoSQL key‑value stores such as Memcached and Redis, compares their strengths and limitations, and proposes a distributed architecture with routing, storage, management, and migration nodes that achieves high availability, automatic fault‑tolerance, load balancing, and elastic scaling.
The article explains that asynchronous programming is essential for creating responsive user interfaces and highly scalable server applications by preventing long‑running operations from blocking UI threads or thread‑pool threads, and outlines the differences between CPU‑bound and I/O‑bound workloads.
This guide explains how to enable MySQL's slow query log, configure it in my.cnf, and compares five popular analysis tools—mysqldumpslow, mysqlsla, mysql-explain-slow-log, mysql-log-filter, and myprofi—detailing their features, output formats, and advantages to help you select the most suitable solution.
Linux cgroups are a kernel feature that organizes processes into hierarchical control groups, allowing fine‑grained limits, accounting, and isolation of CPU, memory, I/O, network and devices via subsystems such as cpu, memory, cpuset, blkio, and others, and are accessed through a virtual filesystem for configuring and managing resource constraints, underpinning containers and cloud platforms.
This article examines the objectives, challenges, evolutionary technologies, design principles, and practical strategies such as resource separation, caching, load balancing, database read/write splitting, CDN, distributed storage, and consistency models that are essential for building and scaling large‑scale website architectures.
