25 docs tagged with "performance"

Detailed guide and senior deep dive into JPA/Hibernate best practices for @ManyToOne and @OneToMany mappings based on Thorben Janssen's tutorial.

A comprehensive guide to Bloom filters, covering probabilistic data structures, implementation details, use cases, interview questions, and real-world applications.

In-depth guide to caching strategies including cache-aside, write-through, write-behind, eviction policies, cache stampede prevention, hotkeys, Redis data structures, and multi-level caching.

CPU scheduling algorithms, metrics, multilevel queues, real-time scheduling, and how the Linux CFS scheduler works.

A complete guide to database connection pooling — how connections work, pool mechanics, HikariCP tuning, pool sizing formulas, failure modes, PgBouncer, RDS Proxy, and production observability. Beginner through senior depth.

Deep dive into Hibernate transaction semantics, locking, N+1 diagnostics, and performance tuning in Spring applications.

Deep dive into database indexing mechanisms — covering disk I/O, B-Trees, hash indexes, composite index design, geospatial indexing, inverted indexes, EXPLAIN analysis, and Spring/JPA performance.

Experienced Java interview scenarios including memory behavior, HashMap resizing, and performance topics.

A comprehensive guide to JPA and Hibernate persistence methods — entity lifecycle states, persist vs save vs merge vs update, primary key strategies, performance implications, and production deep dives for senior engineers.

Guide to JVM internals covering memory layout, garbage collection, class loading, and runtime performance basics.

A complete guide to Kafka brokers — what they are, how storage works, partition leadership, replication, ISR, KRaft vs ZooKeeper, log compaction, performance internals, and production monitoring. Beginner through senior depth.

A deep-dive into techniques for improving Kafka throughput — covering compression, batching, partitions, consumer parallelism, tuning configs, and their trade-offs.

Latency, bandwidth, throughput, connection pooling, keep-alive, HTTP/2 multiplexing, QUIC, compression, and practical tuning techniques.

Deep dive into the Confluent Parallel Consumer model for decoupling thread concurrency from partition counts safely.

Identifying slow queries, profiling tools, key metrics, connection pooling, and practical optimization workflow.

A complete guide to rate limiting — from beginner fundamentals to senior-level distributed design. Covers all algorithms, Redis implementations, decision frameworks, failure modes, and production patterns.

A comprehensive guide to rate-limiting algorithms, including Token Bucket, Leaky Bucket, Fixed Window, Sliding Window Log, and Sliding Window Counter. Covers workflow mechanics, trade-offs, and distributed scaling.

Distributed caching patterns with Redis — cache-aside, write-through, write-behind, read-through — and production concerns like stampede, warming, invalidation, and Spring Cache integration.

Advanced Redis patterns — distributed locking, rate limiting, session management, leaderboards, search, and production performance tuning for senior engineers.

Deep dive into Redis pipelining for throughput optimization, MULTI/EXEC transactions, optimistic locking with WATCH, and atomic Lua scripting — with production patterns and pitfalls.

Strategies for handling high read QPS including caching layers, read replicas, CDN, CQRS, and database indexing. Covers Redis patterns, cache invalidation, consistency models, fan-out strategies, and senior-level deep dives into coherence, hot keys, and tail latency.

Deep-dive into high write throughput techniques — sharding, partitioning, WAL internals, LSM trees, async pipelines, batching, backpressure, idempotency, and distributed transactions — with production Java/Spring code and failure mode analysis.

A complete guide to custom JPQL, Native SQL, SpEL, projections, and senior-level internals — persistence context mechanics, N+1 prevention, memory optimization, and connection pool management.

A comprehensive deep dive into Java thread pools, Netty's event loop model, Tomcat's connector architecture, HikariCP connection pooling, and how they all relate in a Spring Boot application.

A comprehensive guide to virtual memory — covering address spaces, paging mechanics, swap, OOM killer, huge pages, NUMA, and practical Linux/JVM tuning for senior engineers.