This article explains XtraBackup's backup workflow, introduces the --parallel and --compress-threads options, and presents performance test results showing how these parameters can significantly reduce backup time for large MySQL databases.
This article explains how computer systems combine hardware and system software, describes the memory hierarchy, OS abstractions, Amdahl's law, and the three levels of parallelism—thread‑level, instruction‑level, and SIMD—showing why understanding these concepts is essential for writing fast, reliable programs.
This article explains how to extract maximum performance and scalability from PostgreSQL for multi‑terabyte workloads by leveraging specialized indexes, declarative partitioning, tablespaces, parallel query execution, read‑only replica load‑balancing, and foreign‑table sharding techniques.
This article explains why traditional Python threading tutorials are often over‑engineered, introduces the concise map‑based parallelism using multiprocessing and multiprocessing.dummy, and demonstrates how a few lines of code can dramatically speed up I/O‑bound and CPU‑bound tasks.
This article examines how to run several Spark jobs concurrently on a shared SparkContext, balancing full CPU‑vcore utilization with the need to generate fewer Parquet files, and presents practical experiments, scheduling strategies, and performance results.
This article presents a thorough performance comparison of Java Stream API versus traditional for-loop iteration across simple, object, and complex reduction tasks, revealing when serial or parallel streams excel and offering practical recommendations for developers.
This article presents a comprehensive benchmark of Java's Stream API, comparing its serial and parallel performance against traditional loops across primitive, object, and reduction operations, and offers practical recommendations based on multi‑core versus single‑core results.
This article explains the subtle difference between concurrency and parallelism using a ground‑hog and cart analogy, shows how task decomposition creates concurrent pipelines, and maps the model to scalable web‑service architecture, referencing Rob Pike’s talk “Concurrency is not Parallelism”.
This guide walks Kubernetes beginners through the fundamentals of Job, CronJob, and DaemonSet controllers, explaining their use‑cases, key fields such as restartPolicy, backoffLimit, parallelism, and schedule, and provides step‑by‑step YAML examples and command‑line verification to illustrate parallel execution, scheduling, and update strategies.
This article presents a comprehensive benchmark of Java 8 Stream API on large‑scale data, comparing serial and parallel stream operations with traditional external iteration across primitive, object, and reduction workloads, and draws practical recommendations on when to use streams for optimal performance.
This guide presents 24 practical methods—including timing measurements, faster data structures, loop optimizations, vectorization, and parallel processing—to dramatically accelerate Python code, each illustrated with clear before‑and‑after performance screenshots.
This article critiques traditional Python multithreading tutorials and demonstrates how the built‑in map function together with multiprocessing.dummy's ThreadPool can dramatically speed up I/O‑bound and CPU‑bound tasks, offering concise code examples, performance benchmarks, and a real‑world thumbnail generation case study.
This article explains the operating‑system concepts of concurrency and parallelism, illustrates how time‑slicing creates the illusion of simultaneous tasks on a single‑CPU system, defines true parallel execution on multi‑CPU machines, and uses everyday analogies to clarify their differences.
This article explains Spark's role in the DataMagic platform, outlines four practical steps to quickly master Spark, details key configuration and parallelism settings, shows how to modify Spark code, and provides operational tips for cluster management and job troubleshooting.
This article explains the relationships among Storm's core components, how parallelism is calculated from configuration parameters, and how Nimbus performs task assignment and load balancing across workers, supervisors, and executors in a distributed streaming topology.
This article explains how to speed up TensorFlow deep‑learning model training by using a single GPU, configuring session parameters, assigning operations to specific devices, employing multi‑GPU parallelism, and leveraging distributed TensorFlow on Kubernetes, while also discussing synchronous versus asynchronous training modes and practical best practices.
TensorFlow is a dataflow‑based programming model for large‑scale machine learning that uses directed acyclic graphs to represent computations, supports single‑device, multi‑device, and distributed execution with sophisticated node placement, communication, fault‑tolerance, and optimization techniques, and provides tools such as TensorBoard for visualization.
The article explains the CXPACKET wait type in SQL Server, shows how to identify it with diagnostic queries, illustrates its parallelism mechanism with analogies and diagrams, and provides practical steps and hardware recommendations to resolve performance slowdowns caused by this wait.
This article explains what a web crawler is, shows a minimal three‑line Python example, expands it into a functional crawler, identifies common shortcomings, and presents practical solutions such as parallelism, priority queues, DNS caching, Bloom‑filter deduplication, storage choices, and inter‑process communication for building robust distributed scrapers.
This article explores the fundamentals of concurrency versus parallelism, the challenges of writing correct concurrent programs, the evolution from OS threads to green threads, Goroutine scheduling, actor‑model concepts, and modern strategies such as thread pools, async callbacks, and Rust's ownership model.
Adding the right indexes to a complex 12‑table query dramatically cut I/O but unexpectedly increased execution time, and the article explains how an undocumented SQL Server hint forced parallelism to bring the runtime back down.
This article presents a detailed case study of diagnosing Oracle DBtime spikes using Zabbix, custom scripts, AWR and ASH analysis, revealing how scheduler jobs, materialized view refreshes, parallel execution, and unusable indexes caused performance jitter, and demonstrates step‑by‑step remediation to stabilize DBtime.
This article compares four Java concurrency approaches—raw threads, the Executor framework, parallel streams backed by ForkJoinPool, and the Actor model—explaining their implementations, advantages, drawbacks, and typical pitfalls through concrete code examples and practical discussion.
