Crack The Backend

Home Core Backend Algorithms System Design Data Structures

Navigation

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)

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)

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

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

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

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

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)

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

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

DISTRIBUTED SYSTEMS

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

Redis

8 articles

Cache-Aside Pattern Done RightImplementing cache-aside correctly with read-through, write-invalidate, and stampede prevention.Caching Pitfalls - Penetration / Breakdown / AvalancheCache penetration, breakdown, and avalanche.Redis Data Types & Use CasesRedis data structures and when to use them.Distributed Lock with Redis - Correctness & RisksImplementing distributed locks with Redis.Expiration Strategy - TTL DesignTTL and expiration strategies in Redis.Hot Key / Big Key - Detection & MitigationDealing with hot keys and big keys.Rate Limiting with Redis (Token Bucket)Token bucket rate limiting with Redis.Redis Persistence - RDB vs AOF (High-level)RDB and AOF persistence overview.

© 2026 CrackTheBackend. All rights reserved.

Privacy Policy Terms of Service Cookie Settings