This article reviews the history of MySQL and MariaDB, describes a test environment, runs insertion, batch, and query benchmarks (with and without indexes), and concludes that MariaDB generally outperforms MySQL in speed and memory usage while highlighting trade‑offs of indexing.
This article benchmarks Java's traditional for loop, enhanced foreach loop, and Stream API by measuring execution time on 10,000 and 10,000,000 elements, showing that for loops are fastest for small datasets while Stream offers parallelism advantages for large data volumes.
This article explains Java 8 Stream fundamentals, compares intermediate and terminal operations, outlines stream characteristics and advantages over collections, and presents detailed benchmark results comparing Stream, parallel Stream, and traditional iterator across various data‑processing tasks.
This article examines how adding Java thread‑safe classes and the synchronized keyword influences QPS in performance testing, presenting code modifications, benchmark results for 20 and 40 threads, and concluding that their impact on measured throughput is minimal.
This article examines Python's notorious performance lag, explains why its dynamic typing and object overhead make simple loops sluggish, and demonstrates how NumPy's universal functions can accelerate reciprocal calculations by over a thousand times, outperforming even compiled languages.
This article compares traditional Python web frameworks with modern asynchronous alternatives, presents benchmark data showing Sanic’s superior speed, explains the benefits of async I/O, and discusses Sanic’s ecosystem, production readiness, documentation, and community support for developers seeking high‑performance backend solutions.
This article examines three ways to enlarge a positive integer by a factor of one thousand in PHP—concatenating "000", multiplying by 1000, and using the expression X*1024‑X*24—benchmarks each method with ten million iterations, analyses the performance results, and discusses why the binary‑based formula may be slower than direct multiplication.
Phoronix benchmarked PHP 8 (including a JIT‑enabled build) against multiple older PHP versions, showing a modest 7% improvement over PHP 7.4 but a dramatic 92% boost with JIT, making PHP 8 + JIT roughly five times faster than PHP 5.4.
Alibaba Cloud’s Function Compute now offers a container image acceleration feature that reduces pull and decompression times by 50‑80% across various workloads, leveraging on‑demand loading and faster algorithms, with no extra cost, and provides simple enablement via console, CLI, or SDK.
This article explains Go's testing capabilities, covering how to write benchmark functions, use table‑driven and parallel tests, measure code coverage, detect data races with the -race flag, and run static analysis with go vet, providing practical code examples for each feature.
This article reviews the history of MySQL, introduces MariaDB as its open‑source fork, and presents a series of benchmark tests—including single‑row inserts, batch inserts, and various query scenarios—showing that MariaDB generally outperforms MySQL in speed while using more memory.
This article explains TCP concurrency theory, details two experimental approaches for reaching one million simultaneous connections using multi‑IP or multi‑port strategies, and provides step‑by‑step kernel tuning, source code, and validation commands for C, Java, and PHP implementations.
This article explains the importance of unit testing for reliable software, introduces Go's built‑in testing framework, demonstrates how to write test files, use TestMain, benchmark code, and employ the httptest package for HTTP server testing, all illustrated with complete code examples.
This article traces MySQL’s evolution, introduces MariaDB’s origins, and presents a comprehensive benchmark comparing insert and query performance of MySQL 8.0.19 and MariaDB 10.4.12 on identical hardware, highlighting speed differences with and without indexes.
This article presents a systematic benchmark of MySQL 5.7.22 and MySQL 8.0.15 using sysbench to measure TPS and QPS across read‑write, read‑only, and write‑only modes under two persistence configurations, analyzes the results, and provides a Bash script for reproducing the tests.
The article presents a series of Java benchmarks that compare per‑iteration and cumulative string concatenation using String versus StringBuilder, explains why the compiler optimises String concatenation to StringBuilder, and draws conclusions about the most efficient usage patterns in loop‑heavy code.
This article compares the performance of common JavaScript looping constructs—including for, reverse for, forEach, for...of, for...in, and for...await—provides benchmark code on a million‑element array, explains the speed differences, and offers guidance on choosing the right loop for readability and maintainability.
This article traces MySQL’s evolution, introduces its fork MariaDB, and presents a comprehensive performance benchmark—covering single and batch inserts, indexed and non‑indexed queries—on identical hardware, revealing that MariaDB generally delivers faster execution times albeit with higher memory usage.
This article empirically investigates whether Java reflection incurs performance penalties, describing a series of benchmark tests that compare direct method/field access with reflective calls, analyzing results, identifying the main cost factors, and offering practical guidelines to mitigate reflection overhead in production code.
The article compares Java native arrays and Buffer types such as IntBuffer, showing through benchmarks that native arrays are typically over four times faster than Buffers, and discusses the memory management, performance trade‑offs, and practical implications of using each abstraction.
This article presents a series of benchmarks that compare direct method and field access with reflective calls in Java, analyzes where the performance overhead originates, and offers practical guidelines to mitigate reflection‑related slowdown in real‑world applications.
This article examines whether Java microservices can be as fast as Go by presenting a series of benchmark tests using simple services, Helidon and Go toolkits, various JVMs, GraalVM native images, and Kubernetes deployments, and analyzing latency, throughput, and memory usage across multiple hardware configurations.
This article evaluates Alibaba's FastJson library by comparing its parsing speed, Maven popularity, and issue count against Jackson and Gson, presenting benchmark results, highlighting a critical bug in timestamp handling, and concluding with a recommendation to prefer Jackson for most Java projects.
This article explains how to perform MySQL performance benchmarking with the built‑in mysqlslap tool and the third‑party sysbench utility, covering configuration changes, command‑line options, data preparation, execution steps, and interpretation of the resulting metrics.
This article measures the CPU time consumed by Linux process and thread context switches, explains the underlying operations, compares simple token‑passing tests with lmbench benchmarks, and shows how to monitor and interpret switch statistics on a production server.
This guide shows how Go simplifies unit testing, benchmarking, CPU profiling with pprof, and live debugging using dlv, providing step‑by‑step code examples, command‑line usage, and visual analysis techniques for backend developers.
Phoronix’s benchmark of PHP 8 (built from the latest Git source) compares it with previous PHP releases, showing modest gains for the stable version but a dramatic 92% speed increase when JIT is enabled, while also revealing mixed results across different test suites due to I/O bottlenecks.
This article outlines the purpose, timing, procedures, tools, and optimization techniques for big data performance testing, providing detailed guidance on test planning, execution, metric collection, and analysis to ensure reliable and efficient big data system deployments.
This article presents several PHP function alternatives that significantly improve execution speed—such as using array_keys + array_flip for duplicate removal, mt_rand for random selection, ctype_alnum for alphanumeric testing, and strtr for substring replacement—backed by benchmark results and practical tips.
This article investigates whether System.currentTimeMillis suffers from performance problems by examining custom caching implementations, analyzing common misconceptions, presenting benchmark data from both simple loops and JMH tests, and concluding that the native method is sufficiently fast for typical use cases.
This article presents faster PHP alternatives for removing duplicate array values, selecting random elements, testing alphanumeric strings, and replacing substrings, providing benchmark results that show significant speed improvements and discussing trade‑offs and additional coding tips for better script performance.
This article benchmarks Java's ArrayList and LinkedList by measuring insertion and lookup times at the head, tail, and middle of a list with 100,000 elements, then explains the underlying source‑code mechanisms that cause the observed performance differences.
This article investigates whether Java reflection impacts performance by running systematic benchmarks that compare direct method calls, reflective method calls, direct field access, and reflective field access across varying iteration counts, presenting detailed results, analysis of the slow paths, and practical guidelines to mitigate any overhead.
This article presents a systematic benchmark of Java reflection versus direct method and field access, analyzes the measured latency across varying call counts, identifies the costly operations within reflection (such as getMethod, getDeclaredField, invoke, and set), and offers practical guidelines to mitigate reflection‑induced performance overhead.
This article benchmarks Java's Fork/Join framework, Parallel Streams, and ExecutorService across IO‑bound and CPU‑bound workloads on an 8‑core machine, analyzing how thread count and pool configuration affect performance and offering practical recommendations for concurrent Java applications.
This article examines the challenges of existing stream‑processing benchmarks, introduces the open‑source Nexmark framework designed for reproducible, comprehensive performance testing, describes its metrics, query set, workload configurability, and presents experimental results on Flink, highlighting its role in advancing big‑data stream benchmarking.
This article investigates whether Java reflection impacts performance by conducting systematic benchmarks that compare direct method/field access with reflective calls, analyzing the measured overhead, identifying the costly reflection operations, and offering practical guidelines to mitigate any performance penalties.
This article benchmarks UCloud’s Kuaijie‑based UDB against a self‑built MySQL instance on UHost, detailing environment setup, sysbench testing parameters, QPS, insert/delete and update results, and evaluates performance gains of over 20% alongside a cost analysis showing UDB’s better price‑performance ratio.
The article repeats a performance test on a 140 GB MySQL 8 database (innodb_buffer_pool_size=140G) using various innodb_buffer_pool_instances values, showing that increasing the instances improves throughput up to 64 instances, after which no further gains are observed.
The article presents a detailed benchmark of ScaleFlux CSD 2000 storage against Intel SSDs using Percona Server for MySQL 8.0.19 and sysbench, showing how built‑in compression and atomic‑write features give ScaleFlux a clear advantage in large, compressible data sets and high‑concurrency scenarios.
A detailed analysis shows that reducing the size of a database connection pool can dramatically lower request latency and improve throughput, with real benchmark data from Oracle and PostgreSQL illustrating how CPU, disk, and network constraints dictate the optimal pool size.
This article explains the TPC‑C benchmark, covering its purpose, data model, database schema, the five transaction types, and a detailed step‑by‑step walkthrough of the New‑Order operation with accompanying SQL illustrations, while also summarizing workload characteristics and providing reference links.
The article evaluates MySQL 8.0.21's new ability to disable the InnoDB redo log, comparing load‑data performance with redo log enabled and disabled, and discusses practical implications, limitations, and safety considerations for bulk data import scenarios.
This guide explains how to install the HardInfo utility on Linux, use its graphical interface to view detailed hardware components such as CPU, RAM, motherboard, GPU, storage, network, and run built‑in benchmarks, plus how to generate a comprehensive hardware report.
This article explains Caffeine's high‑performance local cache features, presents JMH benchmark results that show it beating Guava, ConcurrentMap and ehcache, details its expiration, refresh and eviction mechanisms, compares memory usage and eviction algorithms, and provides migration code for Guava users.
This article introduces the TPC-C benchmark, its origin within the Transaction Processing Performance Council, the evolution from early standards like Debit Credit and TP1 to TPC-A, the structure of the TPC-C model with its nine tables and operations, and the subsequent development of newer standards such as TPC-E.
This article explains Java's ArrayList structure, compares four traversal methods with benchmark code, analyzes their performance across different list sizes, and outlines safe deletion techniques and common pitfalls such as subList casting and concurrency issues.
Phoronix benchmarked multiple PHP versions, including PHP 8 with and without JIT, revealing that PHP 8 offers modest gains over PHP 7.4 but a dramatic 92% speed increase when JIT is enabled, while older versions lag far behind.
Phoronix’s benchmark of PHP 8 (built from the latest Git source) compares it with PHP 7‑4, older 7.x releases, and legacy 5.x versions, showing a modest 7% speed gain without JIT and a dramatic 92% improvement when JIT is enabled, while highlighting I/O bottlenecks that limit gains in some tests.
This article examines Elasticsearch query performance by explaining Lucene's underlying data structures, describing how composite queries are merged, and presenting benchmark numbers for various query types such as term, range, and combined queries, highlighting optimization techniques and practical conclusions.
This article details a series of practical enhancements applied to an HBase 1.2.4‑based cluster—including layered BucketCache, data pre‑heating, GC‑friendly object pooling, and a multiget concurrency model—that together raise throughput several‑fold and consistently keep P99 latency below 50 ms in YCSB benchmarks.
This article presents a comprehensive performance comparison of OpenJDK 14 with OpenJDK 8 and other major releases, using Phoronix benchmarks across workloads such as SPECjbb, Java 2D, SciMark, DaCapo, Jython, Daytrader, Renaissance, and HBase, and draws conclusions about overall speed trends.
This article explains how to use HBase's built‑in PerformanceEvaluation tool to run baseline read/write latency tests (P99 and P999), describes key command‑line parameters, presents benchmark results for random and sequential operations, and discusses the implications for HBase performance tuning.
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.
The article explains PostgreSQL 11’s new JIT expression compiler, describes how it was benchmarked using the TPC‑H Q1 query on a 22 GB dataset, presents performance improvements over PostgreSQL 10, and provides details on the testing environment, configuration files, and future expectations.
The article explains the origins, metrics, and test suites of TPC and SPEC benchmarks, describes their various models for CPU, web, HPC and storage performance, shows how to query official results, and notes a promotional bundle of technical e‑books.
This article presents seven practical Go performance optimization techniques—including using sync.Pool, avoiding pointer‑heavy maps, generating marshal code, leveraging strings.Builder, preferring strconv over fmt, pre‑allocating slices, and passing byte slices—to reduce garbage collection overhead, improve allocation efficiency, and achieve up to 97% faster execution.
This article benchmarks Java 8 Stream against traditional for‑loops across primitive, object, and complex‑object scenarios, revealing that while for‑loops excel on simple primitive tasks, parallel Stream often outperforms both sequential Stream and loops, especially on multi‑core systems.
This article benchmarks Java 8 Stream against traditional for‑loops and parallel streams across three experiments—primitive array traversal, string list processing, and complex object reduction—using JUnitPerf to measure execution time and analyze when Stream offers real performance benefits.
The article documents a series of Spring Boot 2.1 startup benchmarks on OpenJDK 11, exploring fifteen different tweaks—from using WebFlux instead of WebMVC to enabling AppCDS and disabling unnecessary libraries—showing how each change impacts launch time and culminating in a sub‑second startup.
This article analyzes Java 8 Stream API versus traditional iterator approaches across mapping, filtering, sorting, reduction, string concatenation and mixed operations, presenting benchmark results on various data sizes and offering practical recommendations for when to use streams, parallel streams, or iterators.
Recommendation systems, driven by recent economic and deep‑learning advances, face critical issues such as the lack of unified industrial benchmarks, limited explainability for users and content providers, and feedback‑loop induced data confounding, prompting calls for open datasets, transparent models, and collaborative optimization across stakeholders.
The article explains how Redis 6 introduced multithreaded network I/O to overcome single‑thread bottlenecks, describes the lock‑free read/write flow, provides benchmark configuration and results showing nearly double GET/SET throughput, and outlines upcoming Redis 6.0 features.
Didi’s Elastic Inference Service (EIS) and its IFX AI acceleration engine provide a distributed, cost‑effective inference platform that automatically scales resources based on QPS and latency requirements, supports major deep‑learning frameworks, excels in public‑cloud, private‑cloud, IoT and edge scenarios, and achieved top‑rank DAWNBench latency and cost scores on ImageNet with P4 GPUs.
An objective performance comparison between YugabyteDB (v1.3.0.0) and CockroachDB (v19.1.3) was conducted using the official test scenarios, covering write, read, mixed, secondary index, and transactional workloads on a three‑node Docker environment, with analysis of results and conclusions on their relative strengths.
The article details Redis 6’s new multithreaded I/O feature—motivated by network‑I/O bottlenecks, implemented with lock‑free pending‑read queues that offload reads, writes, and protocol parsing to worker threads while keeping command execution single‑threaded—and demonstrates through a simple benchmark that using four I/O threads roughly doubles GET/SET throughput compared with Redis 5.
RedisConf 2019 highlighted the introduction of multithreaded I/O in Redis 6, detailing its architecture, thread handling of network reads/writes, configuration settings, and benchmark results that show roughly double the throughput for GET/SET commands compared to the single‑threaded Redis 5.0.5.
This article explains the two‑layer architecture of NewLife.Redis, demonstrates basic and advanced usage with code examples, shares stress‑test results achieving hundreds of thousands of operations per second, and provides practical tips and FAQs for high‑performance Redis deployments.
This article enumerates ten frequent Go programming errors—from unknown enum handling and benchmark mis‑optimizations to pointer misuse, slice initialization, context pitfalls, and error‑handling practices—explaining why they occur, showing reproducible code examples, and offering concrete fixes to write more reliable Go code.
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 article walks through a series of practical experiments—ranging from baseline Flux tests to lazy initialization, JVM options, dependency exclusions, and AppCDS—to dramatically reduce Spring Boot application startup time, ultimately achieving sub‑second launch speeds.
This article explains the purpose of UUIDs, common use cases, compares several Java UUID generation libraries, and presents JMH benchmark results showing that the mica implementation based on Java 9 outperforms JDK 8 ThreadLocalRandom and Hutool FastSimpleUUID by three to four times.
The article recounts how a 1960 Playboy portrait of Lena Söderberg was adopted by image‑processing researchers as a standard test image, explains the technical and cultural reasons for its lasting popularity, and follows her unexpected rise to fame within the scientific community.
This article explains Python's asyncio module, presents a practical HTTP keep-alive benchmark tool built with async I/O, details test setup and performance results, and summarizes key asyncio concepts such as event loops, futures, coroutines, and generators.
This article presents eight practical strategies—including upgrading Node.js, leveraging fast-json-stringify, optimizing promises, tuning V8 GC, using streams correctly, and employing node‑clinic tools—to dramatically improve the performance and scalability of Node.js applications.
The 52nd TOP500 list released in November 2018 shows US DOE machines dominating the top ten, highlights performance gains of Summit and Sierra, details the hardware of leading supercomputers worldwide, and analyzes country shares, manufacturers, accelerator usage, interconnect technologies, and energy‑efficiency rankings such as Green500 and HPCG.
This article benchmarks four MySQL stored functions to show how unreachable (dead) code inside functions, procedures, and triggers inflates execution time, visualizes their system calls with performance_schema, and explains the resulting memory and trigger performance impacts.
This article introduces Java Microbenchmark Harness (JMH), explains why precise benchmarking matters, and walks through twelve typical testing pitfalls—such as dead‑code elimination, constant folding, loop misuse, fork isolation, method inlining, false sharing, branch prediction, and multithreading—showing how JMH helps developers obtain reliable performance measurements.
A Chinese company, StarRing Technology, became the first ever to pass the notoriously difficult TPC‑DS benchmark, revealing the test’s history, methodology, and why this achievement marks a major milestone for database performance in the big‑data era.
At QCon 2018 in Beijing, Suning’s Silicon Valley Research Institute showcased its cutting‑edge facial‑recognition system—leveraging ResNet and Inception‑ResNet architectures—to achieve top global rankings and enable real‑time, contact‑less services such as unmanned stores, employee access control, and intelligent store video analytics.
The article analyzes why Go's ioutil.ReadAll becomes a performance bottleneck in IO‑intensive workloads after CPU microcode patches, explains the underlying buffer reallocations, and presents a multi‑level memory‑pool design that reduces allocations and achieves roughly a 19‑fold speedup.
This article explains the concept of asynchronous I/O, introduces Python’s provisional asyncio module, and walks through a complete example that creates an HTTP keep‑alive benchmark tool, including code, test environment, performance results, and key asyncio concepts such as event loops, futures, coroutines, and generators.
This article evaluates popular front‑end frameworks by measuring real‑world performance, bundle size, and source‑code line counts using a medium‑scale blog project, providing practical insights to help developers choose the most suitable framework for their applications.
Through a series of Gradle‑based benchmarks on clean, daemon‑enabled, and incremental builds, this study compares Java and Kotlin compilation times, revealing that while Java is slightly faster on cold builds, Kotlin matches or exceeds Java in typical incremental scenarios.
This article explains Vim’s powerful, extensible features, presents benchmark comparisons of memory consumption and operation speed against editors like Emacs, Nano, VS Code, Atom, Sublime, and shows why many developers still prefer Vim for efficient text editing.
The Intel 545S SSD, featuring a 64‑layer TLC 3D NAND architecture, is evaluated through extensive synthetic and real‑world benchmarks, revealing solid sequential speeds, decent read latency, but notable firmware stability issues that currently limit its recommendation despite an attractive price point.
The article examines why the author favors React for server‑side rendering despite the rise of lightweight libraries like Preact and Inferno, discussing checksum handling, compatibility, maintainability, future roadmap, and presenting benchmark data that shows React@16’s performance gains.
This article translates and expands on Mark Callaghan’s sysbench benchmark, revealing that MySQL 5.6‑5.7 suffers the steepest QPS drop in low‑concurrency tests, compares configurations across versions, presents detailed charts, and concludes that most performance regressions are isolated to the 5.7 release.
This article explains Kafka's distributed architecture, its topic‑partition storage model, replication and synchronization mechanisms, reliability guarantees such as ISR and high‑watermark, and presents benchmark results that illustrate how replication factor, acks settings, and partition count affect throughput and latency.
This article explains how to evaluate SSD performance by processing raw fio benchmark logs, interpreting bandwidth, IOPS, and latency metrics, converting logs to CSV, visualizing results with charts, and drawing practical conclusions for storage selection and reliability.
This article explains how to evaluate SSD performance by detailing the benchmark environment, required hardware, preferred testing tools like fio, essential disk requirements, common pitfalls, and a comprehensive set of test items and scripts for both raw disks and typical filesystems.
This article presents a comprehensive Java benchmark that compares JSON libraries (Jackson, Fastjson, DSL‑JSON, Jsoniter, Thrift) with Google Protocol Buffers across various data types and structures, revealing where Protobuf truly outperforms JSON and where modern JSON parsers narrow the gap.
This article explains the key SSD benchmark indicators—4K random I/O, sustained throughput, performance consistency, durability, and write amplification—while describing why they matter for evaluating storage solutions and guiding proper SSD selection for production workloads.
This article recounts the Huajiao team's migration from PHP 5 to PHP 7, detailing the motivations, upgrade hurdles, extensive performance benchmarks, gray‑release strategy, and operational steps that together delivered up to 30% CPU savings and significant cost reductions.
This article benchmarks Java JSON libraries against Google Protobuf, analyzing decode/encode performance for integers, doubles, strings, objects, and lists, revealing that while Protobuf often outperforms JSON, optimized JSON libraries like DSL‑JSON can narrow the gap dramatically.
The benchmark shows that while InnoDB delivers roughly 30 % higher insert throughput than TokuDB, the TokuDB engine achieves 10‑16× storage compression with comparable import times, minimal impact from log‑sync settings, and zlib emerging as the preferred compression algorithm for balanced performance and CPU usage.
This article presents a detailed benchmark comparing PostgreSQL 9.6 and MySQL 5.7 on identical high‑end hardware using pgbench and SysBench, describing the test methodology, configuration tweaks, performance results for point selects and OLTP workloads, and concluding that both systems scale to modern demanding workloads.
The article summarizes the SPEC 2016 Asian Summit, explains SPEC's role in defining server and cloud performance benchmarks—including CPU, web, and file‑system tests—and highlights the introduction of the SPEC Cloud IaaS 2016 benchmark for evaluating cloud infrastructure performance.
This article benchmarks four widely used RPC frameworks—Dubbo, Motan, rpcx, gRPC, and Thrift—by measuring throughput, average latency, median latency, and maximum latency under varying client concurrency levels, revealing rpcx’s superior performance and the impact of serialization choices.
