Crack the Backend

Home About Privacy Terms Contact

Java Concurrency

Thread Pools in Java
AQS Explained - How Locks Are Built
CompletableFuture - thenApply vs thenCompose
ConcurrentHashMap Internals
Deadlock - How to Detect and Prevent
Java Memory Model (JMM) in Plain English
synchronized vs ReentrantLock
Thread Pools in Java (Core Parameters)
volatile - What It Guarantees (and What It Doesn't)

Database (MySQL)

Index Fundamentals - B-Tree, Covering Index
Locks - Row Lock vs Gap Lock
MVCC Explained
Pagination - Limit/Offset vs Seek Method
Schema Design - Practical Rules of Thumb
Slow Query Diagnosis Workflow
Transactions - Isolation & Common Anomalies

Distributed Systems

CAP Theorem
Consistency Models
Distributed Lock Options
Distributed Transactions
High Availability Basics
High Concurrency Toolkit
Idempotency Design Patterns
Retry, Backoff & Deduplication

Java Core

Java Collections in Practice
ArrayList vs LinkedList - What Actually Matters
Common Design Patterns in Java (Overview)
Generics - Wildcards & Type Erasure
HashMap Deep Dive - Resize, Collisions, Treeify
Java IO vs NIO - When It Matters
Reflection & Annotations - Practical Use Cases
String, StringBuilder, StringBuffer

JVM & GC

Class Loading Process & Parent Delegation
G1 GC Overview - What Problem It Solves
GC Basics - Minor GC vs Full GC
GC Tuning Principles (Not a Flag List)
Java Profiling Basics - What to Measure First
JIT & Escape Analysis (High-level)
JVM Memory Model Explained
OutOfMemoryError Playbook (Symptoms → Causes)

Messaging (Kafka / RocketMQ / RabbitMQ)

Idempotency in Message Consumers
Kafka Core Concepts
Kafka Delivery Semantics (At-least-once etc.)
MQ Basics - Why Asynchronous Matters
Ordering vs Throughput - Trade-offs
RabbitMQ - Exchange / Queue / Routing Key
Retry & DLQ Strategy (Practical)
RocketMQ Overview & Common Scenarios

Microservices & Spring Cloud

API Gateway Basics
Blue-Green vs Canary Deployment
Circuit Breaker, Retry & Timeout
Config Center
Contract Testing Basics
Distributed Tracing Basics
Service Discovery

MyBatis

Batch Insert/Update Patterns
Dynamic SQL Best Practices
MyBatis First/Second Level Cache
Mapper Design for Maintainability
N+1 Query Problem & Fix Patterns
Parameter Binding & SQL Injection Safety
Plugin/Interceptor - When to Use
ResultMap vs ResultType - When It Matters

Redis

Cache-Aside Pattern Done Right
Caching Pitfalls - Penetration / Breakdown / Avalanche
Redis Data Types & Use Cases
Distributed Lock with Redis - Correctness & Risks
Expiration Strategy - TTL Design
Hot Key / Big Key - Detection & Mitigation
Rate Limiting with Redis (Token Bucket)
Redis Persistence - RDB vs AOF (High-level)

RPC (Dubbo)

Common Production Pitfalls in RPC
Dubbo Architecture Overview
Load Balancing Strategies
Rate Limit & Degrade in RPC
RPC Fundamentals - What Happens on a Call
Serialization Tradeoffs
Service Versioning & Compatibility
Timeout, Retry & Fallback

Spring

Spring AOP - Proxy, Pointcut, Advice
Spring Boot Config Priority
Spring Boot Startup Process
Spring IOC & Bean Lifecycle
Spring Security Basics
Transaction Management in Spring
Validation in Spring

System Design

Cache Strategy in System Design
Feed System Basics
File Upload - Presigned URL
Metrics & Monitoring System
Notification System Basics
Payment Idempotency
Rate Limiter Design
URL Shortener Design

RPC (Dubbo)

8 article(s)

Common Production Pitfalls in RPC — Common RPC pitfalls in production.
Dubbo Architecture Overview — Dubbo architecture and core components.
Load Balancing Strategies — RPC load balancing strategies.
Rate Limit & Degrade in RPC — Rate limiting and degradation in RPC.
RPC Fundamentals - What Happens on a Call — What happens when an RPC call is made.
Serialization Tradeoffs — Serialization format tradeoffs in RPC.
Service Versioning & Compatibility — Versioning and compatibility in RPC.
Timeout, Retry & Fallback — Timeout, retry and fallback in RPC.

← Back to home

Home · About · Privacy · Terms · Contact

© 2026 Crack the Backend. Content for engineers.