category · dev

Dev

백엔드 시스템·아키텍처·엔지니어링 실무 — 내부 원리를 파헤치는 기록.

총 291개의 글

DEV 2026.05.05 · 14 min Intermediate Git In Depth · 1

Git이 파일이 아닌 SHA로 세상을 보는 이유

Content-Addressable Storage의 두 가지 결정부터 Merkle tree의 cascade 무결성, delta compression과 GC의 균형까지, Git 객체 저장소의 통합 철학을 추적한다.

DEV 2026.05.05 · 11 min Intermediate Git In Depth · 2

Git의 모든 포인터는 어디에 살고 있는가

로컬 브랜치부터 원격 추적 ref, packed-refs 압축, 특수 참조, detached HEAD까지 — .git 디렉토리 안에서 Git이 현재 위치를 추적하는 방식을 해부한다.

DEV 2026.05.05 · 11 min Intermediate Git In Depth · 3

Git은 파일 변경을 어떻게 추적하는가

index 바이너리 포맷의 stat 캐시부터 3 Tree 모델, git add의 blob 생성, skip-worktree 플래그, .gitignore 매칭 알고리즘까지 — Git staging area의 설계 철학을 추적한다.

DEV 2026.05.05 · 12 min Intermediate Git In Depth · 4

Git history는 왜 DAG인가

Commit 객체의 불변성 설계부터 Reachability 탐색 알고리즘, commit-graph 캐시까지 — Git이 history를 DAG로 표현하는 이유와 그 귀결을 추적한다.

DEV 2026.05.05 · 11 min Intermediate Git In Depth · 5

Git Branch는 왜 이렇게 가벼운가

41바이트 텍스트 파일이 branch의 전부인 이유부터 switch의 3단계 갱신, tracking 설정, 명명 충돌까지 — Git branch 설계 철학을 추적한다.

DEV 2026.05.05 · 10 min Intermediate Git In Depth · 6

Git merge는 어떻게 충돌을 판단하는가

3-way merge의 결정 트리부터 LCA 알고리즘, ort 전략의 100x 가속, rerere의 자동 해결 재사용까지 — Git이 브랜치를 합치는 원리를 추적한다.

DEV 2026.05.05 · 12 min Intermediate Git In Depth · 7

Rebase는 왜 새 commit을 만드는가

commit immutability의 cascade 구조부터 interactive rebase의 todo 파일, --onto의 세 인자, 충돌 해결 전략까지 — rebase의 내부 동작 원리를 추적한다.

DEV 2026.05.05 · 11 min Intermediate Git In Depth · 8

Git에서 변경을 되돌린다는 것의 의미

reset, restore, revert, merge revert, 그리고 reflog 만료까지 — Git이 '되돌리기'를 다섯 가지 다른 방식으로 구현하는 이유를 추적한다.

DEV 2026.05.05 · 11 min Intermediate Git In Depth · 9

git stash는 어떻게 두 영역을 동시에 보존하는가

임시 저장처럼 보이는 stash가 사실 multi-parent commit이라는 것부터, refs/stash 스택 구조, cherry-pick과 rebase의 본질적 동등성까지 Git 내부를 추적한다.

DEV 2026.05.05 · 13 min Intermediate Git In Depth · 10

git push/fetch는 내부에서 무슨 일이 일어나는가

Refspec 문법부터 Smart Protocol의 capability negotiation, want/have 협상, force push 안전성, atomic 트랜잭션까지 — git의 원격 동기화 메커니즘 전체를 추적한다.

DEV 2026.05.05 · 10 min Intermediate Git In Depth · 11

Git은 어떻게 실수를 복구하는가

reflog 파일 구조와 만료 정책부터 fsck 기반 마지막 복구, GC grace period까지 — git 안전망의 전체 설계를 추적한다.

DEV 2026.05.05 · 11 min Intermediate Git In Depth · 12

Git Hook은 어디서 막고 어디서 통과시키는가

client-side 13종 hook의 실행 시점과 server-side pre-receive/update/post-receive의 stdin 구조부터 Husky + lint-staged 자동화까지, 정책 강제의 다층 방어를 추적한다.

DEV 2026.05.05 · 10 min Intermediate Git In Depth · 13

Submodule과 Subtree — 외부 레포 통합의 두 가지 철학

gitlink 객체 구조부터 subtree merge strategy, filter-repo 모노레포 마이그레이션까지, 외부 레포를 통합하는 두 가지 근본적으로 다른 접근을 추적한다.

DEV 2026.05.05 · 11 min Intermediate Git In Depth · 15

Git 워크플로우의 선택은 왜 팀 규모와 신뢰 수준에 달려 있는가

Centralized에서 Forking까지, Git Flow에서 Trunk-Based까지 — 워크플로우 모델의 본질적 차이를 push 권한과 통합 빈도라는 두 축으로 추적한다.

DEV 2026.05.05 · 12 min Intermediate Git In Depth · 14

거대 레포는 어떻게 git을 견디는가

Pack file의 이진 포맷부터 LFS의 Clean/Smudge 필터, Batch API, Partial Clone의 promisor remote, Sparse Index의 100배 가속까지 — git이 거대 저장소 문제를 해결한 방식을 추적한다.

DEV 2026.05.05 · 13 min Intermediate Git In Depth · 16

Git이 Push를 거부할 때 — 7가지 거부의 구조

non-fast-forward부터 permission denied까지, push 거부 메시지별 원인과 안전한 해결 흐름을 추적한다. force push의 함정과 history rewrite 후 협업 프로토콜까지.

DEV 2026.05.05 · 16 min Intermediate Object · 5

객체지향 설계의 세 가지 근본 질문

계약에 의한 설계로 협력을 명시하고, 타입 계층으로 행동을 분류하고, 동적 협력으로 정적 코드를 주도하는 세 원칙이 하나의 철학으로 수렴하는 과정을 추적한다.

DEV 2026.05.05 · 13 min Intermediate Modern Java In Action · 1

람다는 어떻게 바이트코드가 되는가

invokedynamic 명령어의 생성부터 LambdaMetafactory의 런타임 합성, 박싱 회피 함수형 인터페이스의 설계 철학까지, 자바 람다의 내부를 추적한다.

DEV 2026.05.05 · 12 min Intermediate Modern Java In Action · 2

Java Stream은 왜 Terminal 전까지 아무것도 하지 않는가

Lazy evaluation의 본질부터 Sink 체인, Spliterator 분할, Collector의 가변 reduction까지 — Stream API 설계 철학을 관통하는 하나의 원리를 추적한다.

DEV 2026.05.05 · 11 min Intermediate Modern Java In Action · 3

parallelStream()은 왜 항상 빠르지 않은가

ForkJoinPool의 work-stealing 메커니즘부터 NQ 모델 기반 의사결정까지, 자바 병렬 스트림이 빠른 경우와 느린 경우를 가르는 원리를 추적한다.

DEV 2026.05.05 · 12 min Intermediate Modern Java In Action · 4

Optional은 왜 메서드 반환 타입으로만 써야 하는가

Optional의 final class 설계부터 직렬화 금지, Functor/Monad 패턴, 안티패턴, ORM·Jackson 통합까지 — 하나의 설계 철학을 추적한다.

DEV 2026.05.05 · 12 min Intermediate Modern Java In Action · 5

CompletableFuture는 왜 Future를 버렸는가

블로킹 get()의 한계부터 Treiber 스택 콜백 체인, thenApply/thenCompose/thenCombine 선택 기준, Executor 설계, 예외 처리 3가지, allOf/anyOf 패턴까지 비동기 파이프라인 설계의 핵심을 추적한다.

DEV 2026.05.05 · 13 min Intermediate Modern Java In Action · 6

Java 인터페이스는 왜 이렇게 진화했는가

Default Method의 바이트코드 원리부터 Sealed Interface의 ADT 표현까지, Java 인터페이스 설계 철학의 변곡점들을 추적한다.

DEV 2026.05.05 · 12 min Intermediate Modern Java In Action · 7

Java 날짜/시간 API는 왜 이렇게 설계됐을까

LocalDate·ZonedDateTime·Instant의 타입 선택 기준부터 불변성 보장 메커니즘, TemporalAdjuster 패턴, 레거시 마이그레이션 전략까지, java.time 패키지의 설계 철학을 추적한다.

DEV 2026.05.05 · 13 min Intermediate Modern Java In Action · 8

Java는 왜 Record, Sealed, Pattern을 함께 설계했을까

Record의 불변 데이터 구조부터 Sealed의 닫힌 계층, Pattern Matching의 구조 분해까지 — Java 16-21의 세 기능이 하나의 철학으로 수렴하는 과정을 추적한다.

DEV 2026.05.05 · 12 min Intermediate Modern Java In Action · 10

자바 함수형 프로그래밍의 다섯 가지 기둥

고차 함수부터 Either 패턴까지, 자바 함수형 설계의 핵심 원칙과 각 기법이 공유하는 단 하나의 철학을 추적한다.

DEV 2026.05.05 · 12 min Intermediate Modern Java In Action · 9

Virtual Thread는 왜 수백만 개가 가능한가

Platform Thread의 1:1 OS 매핑 비용부터 Continuation 기반 M:N 스케줄링, Pinning 진단, Structured Concurrency 도입까지, Virtual Thread의 설계 철학을 추적한다.

DEV 2026.05.05 · 12 min Intermediate Object · 1

객체는 데이터가 아니라 책임으로 정의된다

절차지향의 God Object부터 책임 주도 설계의 협력 공동체까지, 객체지향의 본질이 '데이터가 아닌 행동'임을 티켓 판매 시스템과 영화 예매 시스템으로 추적한다.

DEV 2026.05.05 · 15 min Intermediate Object · 2

객체지향 설계의 모든 결정은 하나의 질문에서 시작된다

책임 할당(GRASP)부터 메시지 원칙, 객체 분해, 의존성 관리까지 — 좋은 OOP 설계가 공유하는 하나의 철학을 추적한다.

DEV 2026.05.05 · 15 min Intermediate Object · 3

상속은 왜 코드 재사용의 도구가 아닌가

OCP와 DIP부터 취약한 기반 클래스 문제, 합성의 런타임 조합까지 — 상속이 만들어내는 결합도와 그것을 해체하는 방법을 추적한다.

DEV 2026.05.05 · 16 min Intermediate Object · 4

상속은 언제 올바른가 — 서브타이핑, LSP, 그리고 협력의 일관성

is-a 관계의 어휘적 판단이 아니라 클라이언트 관점의 행동 호환성에서 올바른 상속이 시작된다. 리스코프 치환 원칙부터 일관성 있는 협력 패턴, 디자인 패턴까지 설계 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Security Engineering Deep Dive · 5

API 보안의 근본은 하나다 — '신뢰하지 말고 검증하라'

IDOR, 권한 상승, Mass Assignment, Rate Limiting, JWT 클레임 검증, 최소 권한 원칙까지. Spring 기반 API 보안 취약점의 공통 원인과 방어 패턴을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Boot Internals · 4

Spring Boot Actuator는 어떻게 작동하는가

Endpoint 탐색부터 HTTP 경로 등록, 헬스 집계 알고리즘, Micrometer 연동, 운영 환경 보안 설정까지 Actuator 내부 처리 흐름을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Cloud Deep Dive · 7

MSA의 데이터 문제는 어떻게 푸는가

동기 호출의 결합에서 벗어나 EDA·Saga·API Composition·CQRS로 MSA 데이터 흐름을 설계하는 방법을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Jvm Deep Dive · 9

JVM은 객체를 어떻게 들여다보는가

Object Header의 Mark Word 구조부터 Compressed Oops, String Pool, Unsafe API, Reflection Inflation, Java Agent의 바이트코드 변환, JNI 경계 비용까지, JVM이 객체를 다루는 저수준 메커니즘을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Mvc Deep Dive · 7

Spring MVC는 어떻게 요청 하나를 처리하는가

비동기 처리부터 SSE, 파일 업로드, 정적 리소스, HTTP 캐싱, WebMvcConfigurer까지 — Spring MVC 내부 처리 경로의 공통 설계 원칙을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Kubernetes Deep Dive · 7

쿠버네티스는 어떻게 스스로를 운영하는가

Operator 패턴부터 Admission Webhook, Service Mesh, etcd, 멀티 클러스터까지 — 쿠버네티스 확장 철학의 공통 원리를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Security Deep Dive · 7

Spring Security의 모든 방어선은 어디에 서 있는가

CORS Preflight 차단부터 멀티 테넌트 데이터 격리까지, Spring Security가 필터 체인 위에서 구축하는 다층 방어 전략을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Postgresql Deep Dive · 5

PostgreSQL 쿼리 설계의 다섯 가지 축

윈도우 함수부터 LATERAL JOIN, 파티셔닝, Upsert, 다차원 집계까지 — PostgreSQL 고급 쿼리 기능이 공유하는 단일 패스 철학을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Batch Deep Dive · 6

Spring Batch의 병렬 처리는 어떻게 설계되는가

AsyncItemProcessor의 Future 위임부터 Multi-threaded Step의 Thread-safety, @StepScope Late Binding, 이벤트 기반 배치 트리거까지 — 병렬 처리 설계 결정을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Unit Testing · 7

테스트는 코드를 실행했다는 증거가 아니다

커버리지 100%가 버그를 잡지 못하는 이유부터 뮤테이션 테스팅, 속성 기반 테스트, 아키텍처 규칙 자동화, TDD 설계 피드백, 레거시 코드 공략까지 — 검증의 철학을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Docker Deep Dive · 8

Docker는 어떻게 컨테이너를 만드는가

docker run 한 줄 뒤에서 dockerd, containerd, runc가 협력하는 과정부터 OCI 표준이 이 분리를 가능하게 한 이유까지, 런타임 스택의 설계를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Elasticsearch Deep Dive · 5

Elasticsearch 집계는 왜 느리고, 왜 틀릴 수 있는가

Bucket·Metric·Pipeline 3계층 구조와 분산 집계의 2페이즈 실행부터, Terms 오차·fielddata OOM·성능 최적화 전략까지 집계 아키텍처 전체를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Rabbitmq Deep Dive · 1

RabbitMQ는 왜 메시지 브로커인가

동기 호출 체인의 결합도 문제부터 Quorum Queue의 Raft 합의까지, RabbitMQ 설계 전반을 관통하는 '간접성을 통한 안정성' 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Unit Testing · 2

좋은 단위 테스트는 어떻게 쓰는가

단일 동작 검증 원칙부터 경계값 분석, 파라미터화, 픽스처 관리, 의미 있는 단언까지 — 테스트를 설계하는 다섯 가지 핵심 원칙을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Ddd Deep Dive · 7

DDD의 모든 실수는 하나의 질문으로 수렴한다

Anemic Model부터 과잉 Context 분리, DDD 과잉 적용까지 — 도메인 로직이 어디에 있어야 하는가라는 질문 하나가 모든 설계 실수를 관통한다.

DEV 2026.05.02 · 12 min Intermediate Spring Core Deep Dive · 4

Spring AOP는 왜 프록시인가 — 9개 챕터로 보는 하나의 구조

JDK Proxy와 CGLIB의 바이트코드 차이부터 @Transactional·@Cacheable의 Interceptor 체인, private 메서드 함정과 성능 측정까지, 프록시 AOP의 설계 결정을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Msa Deep Dive · 6

API Gateway는 왜 단순한 프록시가 아닌가

필터 체인의 실행 순서부터 서비스 디스커버리, Rate Limiting, JWT 오프로딩, BFF 패턴까지 — MSA 진입점의 설계 결정을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Cloud Deep Dive · 6

Spring Cloud Gateway는 왜 Reactive 기반일까

Zuul 1.x의 Thread-per-Request 한계부터 Filter 체인 실행 순서, 동적 라우팅, Circuit Breaker 통합까지 — Gateway의 모든 설계 결정을 관통하는 하나의 원칙을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Java Design Patterns · 4

아키텍처 패턴의 공통 언어 — 관심사 분리란 무엇인가

Layered Architecture부터 Microservices까지, 8개 아키텍처 패턴이 공유하는 하나의 원칙을 추적한다. 각 패턴은 왜 같은 문제를 다르게 풀었는가.

DEV 2026.05.02 · 17 min Intermediate Architecture Patterns Deep Dive · 1

아키텍처는 폴더 구조가 아니다 — 변경 비용을 통제하는 결정들

소프트웨어 아키텍처의 본질부터 의존성이 변경을 전파하는 메커니즘, SOLID 원칙이 Hexagonal Architecture로 이어지는 논리까지, 설계 결정의 이유를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Architecture Patterns Deep Dive · 5

아키텍처 패턴, 어떻게 고르는가

Layered, Hexagonal, Clean Architecture의 의존성 방향·테스트 속도·복잡도 차이부터, 혼합 전략·ADR·MSA 연계까지 선택 기준을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Kubernetes Deep Dive · 1

쿠버네티스는 왜 모든 것을 API Server를 통해서만 통신하는가

Control Plane과 Data Plane의 역할 분리부터 Reconciliation Loop의 실체, etcd Raft 합의, kubelet Probe, 클러스터 부트스트랩까지 — 하나의 아키텍처 원칙이 모든 설계를 관통하는 방식을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Elasticsearch Deep Dive · 1

Elasticsearch는 어떻게 분산 검색을 완성하는가

Lucene 위에 쌓인 5계층 구조부터 Split-Brain 방지, 라우팅 수식, Scatter-Gather 읽기 경로까지 Elasticsearch의 설계 결정을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Mvc Deep Dive · 3

Spring MVC는 파라미터를 어떻게 바인딩하는가

ArgumentResolver 체인과 HttpMessageConverter 선택부터 @Valid 검증, Custom Resolver 작성까지 — Spring MVC 파라미터 바인딩의 설계 철학을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Java Api Reference · 3

Java 배열과 Arrays 클래스, 무엇을 알아야 하는가

배열의 메모리 구조부터 정렬·검색·복사·변환·다차원 배열까지, Arrays 클래스의 설계 철학과 실전 함정을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Security Deep Dive · 2

Spring Security 인증 아키텍처 — 위임 계층이 설계된 이유

AuthenticationManager부터 커스텀 AuthenticationProvider까지, Spring Security 인증 계층의 설계 철학과 각 컴포넌트가 담당하는 책임을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Security Engineering Deep Dive · 3

인증 시스템은 왜 이렇게 자주 뚫리는가

JWT alg:none부터 OAuth2 PKCE, 세션 고정, CSRF, 브루트포스, 비밀번호 해시까지 — 인증 취약점 6가지가 공유하는 하나의 설계 실수를 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Security Deep Dive · 3

Spring Security 접근 제어는 어떻게 작동하는가

URL 기반 필터부터 메서드 레벨 SpEL, 투표 기반 AccessDecisionManager, 도메인 객체 권한, 커스텀 AuthorizationManager까지 — 선언적 보안의 실행 경로를 추적한다.

DEV 2026.05.02 · 11 min Advanced Spring Boot Internals · 2

Spring Boot Auto-configuration은 어떻게 스스로를 조립하는가

클래스 로딩 없는 조건 평가부터 위상 정렬 기반 순서 결정, DataSource·JPA·MVC 자동 구성, 커스텀 Auto-configuration 작성까지 — Spring Boot가 빈을 조립하는 전 과정을 추적한다.

DEV 2026.05.02 · 17 min Intermediate Msa Deep Dive · 5

MSA 탄력성 패턴 — 장애는 차단하고, 서비스는 살린다

Circuit Breaker의 상태 전이부터 Bulkhead 격리, Exponential Backoff, Timeout 설계, Fallback 전략, Kubernetes 자가 치유까지 — MSA 탄력성 패턴의 통합 철학을 추적한다.

DEV 2026.05.02 · 12 min Intermediate System Design Deep Dive · 3

시스템 설계 면접의 공통 문법

URL 단축부터 검색 자동완성까지, 7가지 시스템 설계 문제를 관통하는 세 가지 패턴 — 확률적 자료구조, 비동기 분리, 읽기 경로 최적화 — 을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Batch Deep Dive · 1

Spring Batch는 왜 Job·Step·Tasklet으로 나누는가

단순 파일 이동부터 100만 건 정산까지, Spring Batch 3계층 실행 구조의 설계 근거와 JobRepository·JobParameters·자동 구성까지 추적한다.

DEV 2026.05.02 · 12 min Intermediate Mysql Deep Dive · 4

MySQL 백업은 왜 --single-transaction 없이 믿을 수 없나

mysqldump 일관성 보장 원리부터 XtraBackup의 Hot Backup, Binary Log 기반 PITR, RTO/RPO 설계, 실전 복구 절차까지 — MySQL 백업·복구의 핵심을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Core Deep Dive · 3

Spring Bean은 어떻게 태어나고 사라지는가

doCreateBean()의 8단계 생성 흐름부터 소멸 콜백의 역순 실행, 3단계 순환 참조 캐시, Scope Proxy의 생명주기 불일치 해결까지, Spring Bean의 전 생애를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Performance Testing Deep Dive · 3

성능 병목은 어디서 오는가 — USE 방법론부터 스레드 덤프까지

CPU·메모리·DB·외부 API·스레드 풀·네트워크 각 계층의 병목을 5분 안에 좁히는 USE 방법론부터 jstack 분석까지, 진단 프레임워크를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Java Design Patterns · 3

Java 행위 패턴은 왜 모두 같은 문제를 푸는가

if-else 지옥부터 복잡한 객체 간 통신까지, Strategy·Observer·Command·State 등 11가지 행위 패턴이 공유하는 하나의 설계 철학을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Jvm Deep Dive · 3

JVM 바이트코드는 어떻게 플랫폼을 초월하는가

클래스 파일 바이너리 구조부터 invoke 명령어의 다형성 구현, 람다의 invokedynamic, 바이트코드 조작까지 — JVM 추상 기계의 설계 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Linux For Backend Deep Dive · 6

컨테이너는 커널 위의 환상이다

namespace로 프로세스 공간을 나누고, cgroups로 자원을 묶고, iptables로 네트워크를 꺽는 방식까지 — 컨테이너를 구성하는 커널 메커니즘의 전체 구조를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Batch Deep Dive · 2

Spring Batch의 Chunk는 왜 Read→Process→Write인가

트랜잭션 경계와 Chunk 크기가 맞물리는 원리부터 Reader 선택·Writer 최적화·Custom ItemStream 구현까지, Spring Batch의 설계 철학을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Db Migration Deep Dive · 6

DB 마이그레이션은 배포 파이프라인의 어디에 있어야 하는가

마이그레이션 타이밍 결정부터 Kubernetes Job 분리, GitHub Actions 승인 게이트, Flyway 감사 이력 추적까지 — 배포 전략과 스키마 변경의 교차점을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Docker Deep Dive · 10

코드 한 줄이 프로덕션에 닿기까지

git push부터 Kubernetes 클러스터 동기화까지, Docker CI/CD 파이프라인의 핵심 설계 결정을 추적한다 — 이미지 태깅, 레지스트리, 보안 스캔, GitOps, 배포 전략까지.

DEV 2026.05.02 · 13 min Intermediate Spring Cloud Deep Dive · 5

Circuit Breaker는 어떻게 연쇄 장애를 막는가

Cascading Failure의 발생 원리부터 Resilience4j의 상태 머신, 슬라이딩 윈도우, Slow Call 탐지, Fallback 체이닝, Bulkhead·Rate Limiter 조합까지, 분산 시스템 방어 메커니즘을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Architecture Patterns Deep Dive · 4

Clean Architecture의 모든 결정은 하나의 규칙에서 나온다

의존성 규칙이 4개 레이어와 테스트 가능성, 인프라 독립성을 어떻게 동시에 만들어내는지, Entities부터 Frameworks까지 구조를 추적한다.

DEV 2026.05.02 · 16 min Advanced Jvm Deep Dive · 1

JVM 클래스로더는 어떻게 JVM을 지탱하는가

Parent Delegation의 보안 원칙부터 바이트코드 검증, 심볼릭 참조 해결, 언로딩 조건, 커스텀 ClassLoader 구현, ClassLoader 격리까지 — JVM 클래스 로딩 전 계층을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Java Api Reference · 7

Java Collections Framework, 하나의 철학으로 읽는다

List의 순서 보장부터 Map의 해시·정렬 설계, Queue와 Stack의 단방향·양방향 구조까지, 16개 챕터를 관통하는 컬렉션 설계 철학을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Cqrs Event Sourcing Deep Dive · 2

CQRS는 왜 Command와 Query를 완전히 다른 세계로 나누는가

CQS 원칙부터 Command 객체 설계, Handler 책임 분배, Bus 미들웨어, 낙관적 잠금, 결과 반환 패턴까지 — CQRS 쓰기 경로의 설계 결정을 하나의 철학으로 추적한다.

DEV 2026.05.02 · 14 min Intermediate Msa Deep Dive · 2

MSA 통신 계층은 왜 이렇게 복잡한가

동기/비동기 선택 기준부터 gRPC 바이너리 인코딩, Kafka Outbox 패턴, API Composition 병렬화, Service Mesh 사이드카, GraphQL Federation까지 — MSA 통신 설계의 공통 철학을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Core Deep Dive · 5

Spring @ComponentScan은 어떻게 수천 개의 클래스를 고르는가

클래스패스 스캔 파이프라인의 시작인 ConfigurationClassPostProcessor부터 BeanDefinition 등록과 인덱스 최적화까지, Spring이 Bean 후보를 선별하는 전체 흐름을 추적한다.

DEV 2026.05.02 · 11 min Advanced Jvm Deep Dive · 7

JVM 동기화는 어떻게 작동하는가

Object Monitor부터 Virtual Thread까지, JVM이 스레드 경쟁을 처리하는 방식과 그 비용을 단계별로 추적한다.

DEV 2026.05.02 · 13 min Intermediate Java Design Patterns · 7

Java 동시성 패턴은 왜 이렇게 설계됐을까

스레드 풀부터 Future/Promise까지, Java 동시성 패턴 6가지의 공통 철학과 각 설계 결정의 이유를 추적한다.

DEV 2026.05.02 · 11 min Intermediate Java Api Reference · 14

Java 동시성은 왜 이렇게 설계됐을까

Thread 생명주기부터 Virtual Thread까지, Java 동시성 API 7개 챕터를 관통하는 설계 철학과 핵심 트레이드오프를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Spring Cloud Deep Dive · 1

Spring Cloud Config는 왜 Git을 설정 저장소로 쓰는가

12-Factor Config 원칙부터 PropertySource 우선순위, RefreshScope 프록시 메커니즘, 암호화, 고가용성까지 — Spring Cloud Config Server의 설계 결정을 추적한다.

DEV 2026.05.02 · 13 min Advanced Java Concurrency Deep Dive · 5

Java 동시성 자료구조는 어떻게 락을 줄이는가

ConcurrentHashMap의 CAS 전환부터 CopyOnWriteArrayList의 스냅샷 보장, BlockingQueue의 분리 락, ConcurrentSkipListMap의 Lock-Free 삭제까지, Java 동시성 컬렉션의 설계 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Core Deep Dive · 6

Spring @Configuration은 어떻게 싱글톤을 보장하는가

Full Mode와 Lite Mode의 구분 기준부터 CGLIB 서브클래스 생성, BeanMethodInterceptor의 인터셉션, @Import의 3가지 처리 경로까지, Spring Core의 설정 메커니즘을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Kafka Deep Dive · 4

Kafka Consumer는 왜 멈추는가

Consumer Group 상태 머신과 리밸런싱 발생 조건부터 Cooperative 전략, 중복 처리 방지, Lag 진단까지 — Consumer가 멈추는 모든 이유를 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Data Transaction · 6

HikariCP는 왜 다른 Connection Pool보다 빠른가

Lock-free ConcurrentBag 구조부터 타임아웃 파라미터 설계 원칙까지, HikariCP가 고성능을 유지하는 내부 메커니즘을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Java Design Patterns · 1

Java 생성 패턴, 무엇을 왜 선택하는가

Singleton의 Thread-safety부터 Object Pool의 재사용 철학까지, Java 생성 패턴 6개를 관통하는 하나의 질문을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Network Deep Dive · 7

컨테이너 네트워크는 어떻게 작동하는가

Docker veth 페어와 iptables NAT부터 K8s kube-proxy의 ClusterIP 구현, 운영 중 RST·포트 고갈 패턴, RTT 기반 성능 측정까지 컨테이너 네트워킹의 전 계층을 추적한다.

DEV 2026.05.02 · 17 min Advanced Msa Deep Dive · 3

MSA에서 데이터는 어떻게 분리되고 어떻게 다시 합쳐지는가

Database per Service 원칙부터 Polyglot Persistence, JOIN 없는 조회 전략, ACID vs BASE, 데이터 이관, 서비스 간 참조 무결성까지 MSA 데이터 아키텍처의 핵심 트레이드오프를 추적한다.

DEV 2026.05.02 · 15 min Intermediate System Design Deep Dive · 5

대규모 데이터 시스템, 무엇을 포기하고 무엇을 얻는가

Lambda/Kappa 아키텍처 선택부터 시계열 DB 다운샘플링, Redis Cluster 슬롯 분산, 샤딩 전략, 글로벌 복제 일관성까지 — 데이터 시스템 설계의 근본 트레이드오프를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Java Api Reference · 11

Java 8 Time API는 왜 기존 Date를 버렸는가

가변 객체와 스레드 불안전이라는 레거시 API의 근본 결함부터 불변성·타입 안정성·시간대 분리라는 java.time의 설계 철학까지, 날짜/시간 처리의 전환점을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Performance Testing Deep Dive · 5

DB 성능 튜닝은 어디서 시작해야 하는가

HikariCP 풀 크기 공식부터 OFFSET 페이징의 O(n) 함정까지, 실무 DB 성능 문제의 구조적 원인과 해결 전략을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Ddd Deep Dive · 1

DDD는 복잡도를 어떻게 다루는가

Anemic Domain Model이 Service 비대화로 이어지는 원인부터 Strategic/Tactical Design의 역할 분담, 레이어 의존성 역전까지 — DDD의 설계 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Docker Deep Dive · 11

컨테이너 디버깅은 왜 이렇게 어려운가

격리된 컨테이너 내부를 들여다보는 방법부터 네트워크 장애, 성능 병목, 자주 반복되는 문제 패턴까지 — 컨테이너 트러블슈팅의 전체 지형을 추적한다.

DEV 2026.05.02 · 12 min Intermediate System Design Deep Dive · 7

아키텍처 결정은 어떻게 기억되는가

ADR로 결정을 기록하는 방법부터 기술 부채 상환 전략, 성장 단계별 아키텍처 선택, FinOps 실천까지 — 팀의 기술 판단을 지속 가능하게 만드는 원칙을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Kafka Deep Dive · 3

Kafka는 어떻게 메시지를 정확히 전달하는가

At-Most-Once부터 Exactly-Once까지, Kafka 전달 보장의 전 계층을 추적한다. Producer 멱등성, 트랜잭션 Two-Phase Commit, Consumer offset 커밋 타이밍이 어떻게 맞물려 최종 보장을 결정하는지 살펴본다.

DEV 2026.05.02 · 12 min Intermediate Spring Core Deep Dive · 2

Spring DI는 왜 생성자 주입을 권장하는가

바이트코드 레벨 차이부터 3단계 순환 참조 캐시, @Qualifier 결정 알고리즘, ObjectProvider, @Lazy 프록시까지 — Spring DI 내부 설계의 일관된 원칙을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Kubernetes Deep Dive · 6

Kubernetes 배포는 왜 이렇게 설계됐는가

롤링 업데이트 알고리즘부터 Probe 삼각편대, RBAC 최소 권한, 설정 갱신 방식, 모니터링 파이프라인까지 — Kubernetes 운영 설계의 일관된 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Cicd Deep Dive · 4

배포 전략의 진짜 선택 기준은 무엇인가

Rolling Update부터 Canary, Blue-Green, Argo Rollouts까지 — 각 배포 전략이 어떤 트레이드오프를 가지며, 언제 무엇을 선택해야 하는지 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Boot Internals · 6

Spring Boot DevTools는 어떻게 개발 루프를 단축하는가

LiveReload WebSocket 통신부터 두 ClassLoader 분리 전략, Fat JAR 구조까지, DevTools가 개발 사이클을 최적화하는 설계 결정을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Mvc Deep Dive · 1

DispatcherServlet은 어떻게 HTTP 요청을 응답으로 만드는가

Front Controller 패턴부터 doDispatch() 9단계, HandlerMapping 체인, HandlerAdapter, ViewResolver까지 Spring MVC 요청 처리의 전체 여정을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Performance Testing Deep Dive · 7

성능 테스트가 거짓말을 하는 이유

단일 머신 k6의 한계부터 JVM 컨테이너 메모리 오인식, Circuit Breaker 복구 검증까지, 실제 트래픽을 재현하는 테스트 인프라의 설계 원칙을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Cloud Deep Dive · 3

분산 추적은 어떻게 서비스 경계를 넘는가

TraceContext 전파부터 Baggage, MDC 자동 주입, Zipkin 시각화까지 — Spring Cloud 분산 추적의 전체 흐름을 하나의 구조로 추적한다.

DEV 2026.05.02 · 13 min Intermediate Observability Deep Dive · 3

분산 추적은 어떻게 서비스 경계를 넘는가

Trace와 Span의 데이터 모델부터 W3C TraceContext 전파, 비동기 Context 손실까지 — 분산 추적이 마이크로서비스를 꿰뚫는 원리를 추적한다.

DEV 2026.05.02 · 12 min Intermediate Network Deep Dive · 5

DNS는 어떻게 IP를 찾는가

브라우저 주소창에서 시작한 도메인 조회가 Root NS, TLD NS, Authoritative NS를 거쳐 IP로 바뀌는 전 과정을 추적한다. TTL 캐시 전략부터 DNSSEC, JVM DNS 캐시 함정까지.

DEV 2026.05.02 · 12 min Intermediate Cicd Deep Dive · 3

Docker 이미지 빌드, 순서가 전부다

레이어 캐시 원리부터 멀티 스테이지 빌드, BuildKit 병렬 실행, 보안 강화, Spring Boot 최적화, 레지스트리 태그 전략까지 — 느린 빌드의 원인과 해결을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Ddd Deep Dive · 4

Domain Event는 어떻게 결합도를 끊는가

발행자가 구독자를 모르는 설계부터 Outbox Pattern의 원자성 보장, Saga의 보상 트랜잭션, ACL의 번역 계층까지 — DDD 이벤트 기반 설계의 핵심을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Java Design Patterns · 5

Java 레이어드 아키텍처 패턴, 왜 이렇게 나뉘어 있는가

DTO의 보안 경계부터 Specification의 규칙 조합까지, 레이어드 아키텍처를 구성하는 5개 패턴의 설계 철학과 트레이드오프를 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Boot Internals · 5

Spring Boot 내장 서버는 어떻게 뜨는가

Tomcat·Jetty·Undertow 아키텍처 차이부터 ServletWebServerFactory 초기화 경로, SSL/TLS·HTTP/2·다중 포트 설정까지, 내장 서버의 전체 생명주기를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Java Api Reference · 5

Java Enum은 단순한 상수 묶음이 아니다

타입 안전성의 출발점부터 전략 패턴·상태 머신·싱글톤까지, Enum이 하나의 설계 언어로 기능하는 방식을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Batch Deep Dive · 4

Spring Batch는 실패한 1건을 어떻게 격리하는가

FaultTolerantChunkProcessor의 스캐터-개더 패턴부터 Custom SkipPolicy 구현까지, Spring Batch 오류 처리 전략의 설계 철학을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Cqrs Event Sourcing Deep Dive · 3

Event Sourcing은 왜 '이벤트를 진실의 원천'으로 삼는가

현재 상태 저장의 본질적 한계부터 이벤트 스토어 설계, Aggregate 재구성, 스냅샷 패턴, 스키마 진화, 그리고 도입을 피해야 할 상황까지 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Mvc Deep Dive · 5

Spring MVC 예외는 어떻게 응답이 되는가

HandlerExceptionResolver 체인의 구조부터 @ExceptionHandler 매칭 알고리즘, @ControllerAdvice 우선순위, RFC 7807 ProblemDetail까지, Spring MVC 예외 처리의 전체 경로를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Spring Core Deep Dive · 7

Spring 이벤트는 언제, 어떤 스레드에서 실행되는가

publishEvent() 내부 구조부터 @TransactionalEventListener의 트랜잭션 바인딩까지, Spring ApplicationEvent 메커니즘의 실행 흐름을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Java Api Reference · 6

Java 예외는 어떻게 설계해야 하는가

예외 계층 구조의 출발점부터 커스텀 예외 설계, Exception 체인, 그리고 실무 안티패턴까지, Java 예외 처리의 전체 그림을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Jvm Deep Dive · 4

JVM은 바이트코드를 어떻게 실행하는가

Interpreter의 즉시 실행부터 JIT 계층화 컴파일, OSR, Deoptimization, Intrinsics까지 — HotSpot이 성능을 끌어올리는 원리를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Rabbitmq Deep Dive · 2

RabbitMQ Exchange는 어떻게 메시지를 찾아가게 하는가

Direct의 O(1) 해시 매칭부터 Topic 와일드카드, Fanout 브로드캐스트, Headers 다차원 조건, DLX 안전망까지 — Exchange 설계 결정의 통일된 철학을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Linux For Backend Deep Dive · 4

리눅스 파일 I/O는 어떻게 설계되어 있는가

VFS 추상화부터 fsync 내구성 보장까지, 리눅스 파일 I/O 스택의 다섯 개 레이어가 공유하는 하나의 원칙을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Db Migration Deep Dive · 2

Flyway는 어떻게 마이그레이션을 신뢰하는가

flyway_schema_history의 체크섬 원리부터 동시성 Lock, 마이그레이션 유형 선택, Callback 자동화, 체크섬 불일치 해결까지 — Flyway 설계 철학의 다섯 층을 추적한다.

DEV 2026.05.02 · 15 min Intermediate System Design Deep Dive · 1

시스템 설계의 모든 결정은 하나의 질문으로 귀결된다

확장성과 가용성의 수학적 계산부터 CAP 트레이드오프, 데이터 모델 선택, 면접 프레임워크까지 — 분산 시스템 설계의 핵심 원칙을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Docker Deep Dive · 1

컨테이너는 어떻게 격리되면서도 빠른가

VM과의 근본적 차이부터 Namespace·Cgroups·OverlayFS의 내부 동작까지, Docker가 프로세스 격리를 통해 성능을 지키는 방식을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Jvm Deep Dive · 5

JVM GC는 어떻게 살아있는 객체를 판단하는가

GC Roots와 Reachability Analysis부터 Serial/Parallel/CMS/G1/ZGC까지, JVM 가비지 컬렉터의 설계 결정과 그 대가를 추적한다.

DEV 2026.05.02 · 12 min Intermediate Java Api Reference · 4

Java Generics는 왜 타입을 지운가

컴파일 타임 타입 안전성의 근본 원리부터 Type Erasure의 설계 결정, PECS 원칙까지 — Java Generics의 통일된 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Cicd Deep Dive · 2

GitHub Actions의 설계 철학 — 격리, 계층, 명시성

YAML 파싱부터 OIDC 인증까지, GitHub Actions의 모든 핵심 메커니즘이 공유하는 하나의 원칙을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Cicd Deep Dive · 5

GitOps는 배포 도구가 아니라 감사 시스템이다

Git 커밋이 신뢰할 수 있는 배포 감사 추적이 되기까지, GitOps 4원칙부터 멀티 클러스터 ApplicationSet, Secret 암호화 전략까지 추적한다.

DEV 2026.05.02 · 13 min Intermediate Observability Deep Dive · 6

관찰 가능성 스택은 어떻게 하나로 연결되는가

Grafana 플러그인 구조부터 Exemplar를 통한 메트릭-트레이스 연결, 증상 기반 알림 설계, RED/USE 진단 프레임워크까지, 관찰 가능성의 통합 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Grpc Deep Dive · 1

gRPC는 왜 REST보다 마이크로서비스에 맞는가

JSON 직렬화 비용과 HTTP/1.1 연결 오버헤드부터 HTTP/2 멀티플렉싱, 4가지 통신 패턴, 생태계 조합까지 — gRPC의 설계 결정을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Architecture Patterns Deep Dive · 3

Hexagonal Architecture는 왜 도메인이 아무것도 모르게 설계하는가

레이어드 아키텍처의 의존성 문제부터 Port/Adapter 구조, DDD 통합, 실제 비용까지 — Hexagonal의 철학과 트레이드오프를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Network Deep Dive · 3

HTTP는 어떻게 진화했는가 — 1.1의 한계부터 QUIC까지

HOL Blocking이라는 단 하나의 적을 쫓아가다 보면, HTTP/1.1의 Keep-Alive, HTTP/2의 멀티플렉싱, HTTP/3의 QUIC이 하나의 연속된 이야기가 된다.

DEV 2026.05.02 · 12 min Intermediate Database Internals · 2

데이터베이스 인덱스는 왜 B+Tree인가

Binary Search Tree의 한계부터 Covering Index, Composite Index 순서 설계, 인덱스를 무력화하는 쿼리 패턴까지, B+Tree가 만들어내는 모든 설계 결정을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Postgresql Deep Dive · 3

PostgreSQL 인덱스는 왜 이렇게 많은가

B-Tree의 Visibility Map부터 BRIN의 블록 범위, GIN의 역색인, Bloom의 확률적 서명까지 — PostgreSQL 인덱스 생태계의 설계 철학을 하나의 질문으로 추적한다.

DEV 2026.05.02 · 12 min Intermediate Docker Deep Dive · 2

Docker 이미지 크기가 10배 차이 나는 이유

Dockerfile 레이어 순서부터 멀티 스테이지 빌드, BuildKit 캐시 마운트, Distroless 보안까지 — Docker 빌드 최적화의 통합 원리를 추적한다.

DEV 2026.05.02 · 13 min Intermediate System Design Deep Dive · 2

트래픽 진입점 설계 — DNS부터 스토리지까지

로드밸런서, CDN, 캐싱, 메시지 큐, DB 확장, 검색, 스토리지까지 — 대규모 시스템의 각 계층이 어떤 하나의 원칙 아래 연결되는지 추적한다.

DEV 2026.05.02 · 12 min Intermediate Security Engineering Deep Dive · 2

인젝션 취약점의 공통 구조: 파서를 속이는 법과 막는 법

SQL, Blind SQL, JPA/JPQL, Command, LDAP/XML/NoSQL까지 — 모든 인젝션이 공유하는 단 하나의 근본 원인과 PreparedStatement가 그것을 막는 내부 메커니즘을 추적한다.

DEV 2026.05.02 · 15 min Advanced Cqrs Event Sourcing Deep Dive · 5

CQRS + Event Sourcing의 설계 결정은 어디서 오는가

완전한 흐름의 각 단계 책임부터 원자성 보장, DDD 통합, 처리 보장, 성능 최적화, MSA 통합까지 — 하나의 철학이 만드는 아키텍처를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Unit Testing · 5

단위 테스트가 통과해도 시스템이 망가지는 이유

경계(boundary)에서 발생하는 통합 실패의 근본 원인부터 Testcontainers, 슬라이스 테스트, 트랜잭션 함정, Contract Testing까지 — 각 레이어가 연결되는 지점을 테스트하는 방법을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Mvc Deep Dive · 6

Spring MVC 요청 파이프라인은 어떻게 설계됐는가

Filter와 HandlerInterceptor의 실행 위치 차이부터 비동기 요청에서 ThreadLocal 오염이 발생하는 이유까지, Spring MVC 요청 처리 계층의 설계 원칙을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Linux For Backend Deep Dive · 3

Linux I/O 모델은 왜 이렇게 설계됐는가

파일 디스크립터의 정체부터 epoll의 O(1) 이벤트 처리까지, Blocking/Non-Blocking/Multiplexing I/O의 설계 결정과 백엔드 프레임워크 선택의 근거를 추적한다.

DEV 2026.05.02 · 11 min Intermediate Java Api Reference · 12

Java IO는 왜 이렇게 복잡한가

File 클래스의 경로 표현부터 바이트/문자 스트림 분리, 객체 직렬화까지 — Java IO 계층의 설계 결정을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Core Deep Dive · 1

Spring 컨테이너는 어떻게 설계되었는가

BeanFactory의 최소 계약부터 BeanDefinition, BeanPostProcessor, ApplicationContext 계층, PropertySource 우선순위, Resource 추상화까지 — 스프링 컨테이너를 관통하는 설계 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Observability Deep Dive · 2

Java Agent는 코드 한 줄 없이 어떻게 계측하는가

premain()부터 ByteBuddy @Advice 인라인 삽입까지, OTel Java Agent가 Spring MVC와 JDBC를 자동 계측하는 전체 메커니즘을 추적한다.

DEV 2026.05.02 · 14 min Advanced Java Concurrency Deep Dive · 2

Java 동시성의 모든 규칙은 하나의 질문에서 나온다

CPU 캐시 가시성 문제부터 JMM 추상화, happens-before 전이성, volatile 메모리 펜스, 명령어 재정렬, DCL 함정까지 — Java 동시성 설계의 단일 원리를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Jvm Deep Dive · 6

Java Memory Model은 무엇을 추상화하는가

CPU 캐시 불일치와 명령어 재정렬이 만드는 가시성 문제부터, Happens-Before·volatile·final·Memory Barrier가 이를 해결하는 방식까지, JMM 전체 철학을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Batch Deep Dive · 3

Spring Batch Job Flow는 어떻게 실행을 제어하는가

SimpleJob의 순차 실행부터 Conditional Flow, JobExecutionDecider, 병렬 Split, Flow 외부화, Listener까지 — Spring Batch가 배치 단계를 제어하는 일관된 설계를 추적한다.

DEV 2026.05.02 · 15 min Intermediate Spring Data Transaction · 3

JPA는 어떻게 객체와 DB를 동기화하는가

EntityManager 프록시의 정체부터 Dirty Checking, N+1 해결, Lazy 프록시, Batch INSERT까지 — JPA 내부 동기화 메커니즘의 설계 원칙을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Performance Testing Deep Dive · 4

JVM 성능 문제는 어디서 오는가

GC 로그 분석부터 Heap Dump, Flame Graph, JVM 튜닝, Actuator 메트릭까지 — Java 애플리케이션 성능 저하의 원인을 추적하는 계층적 진단 체계를 정리한다.

DEV 2026.05.02 · 13 min Intermediate Spring Security Deep Dive · 5

JWT는 왜 서명만 하고 암호화하지 않는가

위조 방지를 위한 HMAC 서명부터 RTR 기반 Refresh Token 탈취 감지까지, Spring Security JWT 인증 체계의 설계 결정을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Performance Testing Deep Dive · 2

성능 테스트 도구는 왜 아키텍처가 결과를 결정하는가

고루틴 기반 VU부터 Executor 선택, 토큰 재사용, 백분위수 해석, InfluxDB 연동, 실전 주문 플로우까지 — k6가 설계 결정마다 드러내는 성능 테스트의 핵심 원칙을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Kafka Deep Dive · 6

Kafka Streams의 모든 설계는 어디에서 왔는가

Topology와 Task의 1:1 대응부터 Outbox Pattern의 원자성 보장까지, Kafka Streams의 아키텍처 결정들을 하나의 철학으로 추적한다.

DEV 2026.05.02 · 14 min Intermediate Kafka Deep Dive · 1

Kafka는 왜 메시지 큐가 아닌 분산 로그인가

메시지를 소비해도 삭제하지 않는 설계 결정부터 순차 I/O, Zero-Copy, KRaft까지 — Kafka의 모든 선택이 '로그'라는 하나의 철학에서 나온다.

DEV 2026.05.02 · 12 min Intermediate Docker Deep Dive · 13

Docker에서 Kubernetes로 — 무엇이 달라지는가

docker-compose.yml 한 파일로 충분했던 세계에서, 왜 Deployment·Service·PVC·ConfigMap이 필요해지는가. 개념 매핑부터 마이그레이션 트레이드오프까지 추적한다.

DEV 2026.05.02 · 14 min Intermediate Java Api Reference · 8

Java 함수형 인터페이스는 왜 이렇게 설계됐을까

Supplier부터 커스텀 함수형 인터페이스까지, Java 람다 생태계의 공통 철학인 '타입으로 표현된 함수'를 추적한다.

DEV 2026.05.02 · 14 min Intermediate System Design Deep Dive · 4

대규모 서비스 설계의 공통 언어

동영상 스트리밍부터 위치 기반 서비스까지, 7개 시스템 설계 문제에서 반복되는 핵심 패턴과 트레이드오프 결정 원칙을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Architecture Patterns Deep Dive · 2

레이어드 아키텍처는 왜 시간이 지날수록 무너지는가

Controller-Service-Repository를 나눴는데도 Fat Service와 DTO 침투가 생기는 이유부터 DIP로 구조적 한계를 넘어서는 경로까지, 레이어드 아키텍처의 설계 결정을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Network Deep Dive · 6

트래픽을 제어하는 다섯 가지 원칙

L4/L7 분기 선택부터 서킷 브레이커의 Half-Open 탐침까지, 네트워크 계층별 트래픽 제어 패턴이 공유하는 하나의 설계 철학을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Cloud Deep Dive · 4

Spring Cloud LoadBalancer는 어떻게 서비스 이름을 IP:Port로 바꾸는가

Ribbon 종료 선언부터 Custom LoadBalancer 구현까지, Spring Cloud LoadBalancer의 내부 호출 체인과 설계 철학을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Database Internals · 5

InnoDB Lock은 왜 인덱스 레코드에 걸리는가

S/X Lock의 호환 행렬부터 Gap Lock Deadlock, 데드락 로그 분석, Optimistic vs Pessimistic 선택까지 — InnoDB Lock 설계의 일관된 원리를 추적한다.

DEV 2026.05.02 · 13 min Advanced Java Concurrency Deep Dive · 4

Java CAS의 설계 철학 — 원자성, 경쟁, 그리고 트레이드오프

CPU 레벨 LOCK CMPXCHG부터 LongAdder의 Cell 분산, ConcurrentLinkedQueue의 Lock-Free 설계, VarHandle 메모리 오더링까지 Java CAS 생태계의 통일된 원리를 추적한다.

DEV 2026.05.02 · 13 min Advanced Java Concurrency Deep Dive · 3

Java 락은 어떻게 스스로를 최적화하는가

Object Header의 Mark Word 비트 레이아웃부터 AQS 대기 큐, StampedLock 낙관적 읽기, JIT Lock Elision까지 — Java 동시성 락 계층의 설계 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Observability Deep Dive · 5

로그는 왜 구조여야 하는가 — Observability 로깅의 설계 철학

텍스트 grep에서 JSON 필드 검색까지, 구조화 로그가 장애 대응 속도를 어떻게 바꾸는지 — MDC 전파, Loki 인덱스 설계, 동적 레벨 변경까지 추적한다.

DEV 2026.05.02 · 12 min Intermediate Elasticsearch Deep Dive · 2

Elasticsearch는 왜 역색인인가

MySQL LIKE 검색의 Full Scan 한계부터 FST 압축, 불변 세그먼트, NRT, doc_values까지 — Elasticsearch 내부 설계 결정의 공통 원리를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Java Api Reference · 2

Java 수 타입의 설계 철학 — 왜 세 가지가 필요한가

int와 double의 한계부터 Wrapper 클래스의 박싱 함정, BigDecimal의 정확성 보장까지, Java 수 타입 계층이 만들어진 이유를 추적한다.

DEV 2026.05.02 · 16 min Intermediate Linux For Backend Deep Dive · 2

Linux 메모리는 백엔드 성능을 어떻게 결정하는가

가상 메모리와 Page Table 변환부터 Page Fault, Page Cache, mmap/O_DIRECT, 메모리 할당기 단편화, OOM Killer까지 — 백엔드 서비스 메모리 트러블슈팅의 전체 지형을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Rabbitmq Deep Dive · 3

RabbitMQ 메시지 유실은 왜 조용히 일어나는가

Publisher Confirm부터 Consumer Ack, 영속성 설정, 재시도 전략, Outbox Pattern까지 — RabbitMQ 메시지 보장의 세 지점과 그 설계 원리를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Rabbitmq Deep Dive · 4

RabbitMQ 메시지 패턴의 공통 철학은 무엇인가

Work Queue의 Prefetch부터 Saga 패턴의 보상 트랜잭션까지, RabbitMQ의 여섯 가지 메시지 패턴이 공유하는 설계 원칙을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Unit Testing · 3

Mock은 하나가 아니다 — Test Double의 다섯 얼굴

Dummy부터 Fake까지 다섯 종류의 Test Double이 왜 존재하는지, 잘못된 선택이 어떤 버그를 숨기는지, 그리고 verify()를 언제 써야 하는지 추적한다.

DEV 2026.05.02 · 14 min Intermediate Java Api Reference · 9

Modern Java의 불변 설계 — Record, Switch, Sealed Class

50줄 보일러플레이트를 1줄로 줄이는 Record부터, 완전성을 컴파일 타임에 강제하는 Sealed Class까지, Modern Java가 공유하는 하나의 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Java Design Patterns · 6

Java 함수형 패턴의 공통 철학은 무엇인가

Functional Interface, Stream Pipeline, Optional, Sealed Classes까지 — Java 현대 패턴들이 공유하는 '선언적 제어'의 원리와 트레이드오프를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Mysql Deep Dive · 6

MySQL은 어디서 얼마나 걸리는가

Performance Schema의 누적 통계부터 InnoDB 상태 스냅샷, sys 스키마, MySQL 8.0 히스토그램, 운영 장애 패턴까지 — 데이터 기반 진단 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Cicd Deep Dive · 7

CI/CD 파이프라인의 다섯 가지 신호

배포 추적부터 장애 복구까지, 파이프라인이 침묵하는 순간 팀이 잃는 것을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Postgresql Deep Dive · 2

PostgreSQL은 왜 삭제해도 테이블이 줄지 않는가

Dead Tuple 생성부터 VACUUM 내부 흐름, HOT Update 최적화, XID Wraparound 위기까지 — PostgreSQL MVCC가 치르는 비용과 그 관리 전략을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Webflux Deep Dive · 3

WebFlux의 처리량은 Netty 구조에서 온다

Boss/Worker EventLoopGroup 분리부터 ChannelPipeline, EventLoop 블로킹 위험, ConnectionProvider 연결 풀 튜닝까지, Spring WebFlux의 성능 설계를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Network Deep Dive · 1

네트워크는 왜 계층으로 나뉘는가

OSI 7계층부터 NAT 동작 원리까지, 계층 모델이 만들어내는 독립성과 그 대가를 패킷의 시선으로 추적한다.

DEV 2026.05.02 · 13 min Intermediate Linux For Backend Deep Dive · 5

Linux 소켓은 어디서 멈추는가

send() 반환이 전송 완료가 아닌 이유부터 Zero Window, Accept Queue 포화, TCP_NODELAY, sendfile()까지 — 커널이 데이터를 움직이는 실제 경로를 추적한다.

DEV 2026.05.02 · 11 min Intermediate Docker Deep Dive · 3

Docker 네트워크는 어떻게 패킷을 옮기는가

veth pair와 bridge 생성부터 iptables NAT, Overlay VXLAN, 네트워크 보안 정책까지 — Docker 컨테이너 네트워킹의 전체 흐름을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Kubernetes Deep Dive · 3

쿠버네티스 네트워킹은 어떻게 동작하는가

IP-per-Pod 모델의 보장 원리부터 CNI, kube-proxy iptables 체인, Ingress, CoreDNS, Network Policy까지 — 클러스터 네트워크를 관통하는 단일 설계 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Security Deep Dive · 6

Spring Security OAuth2는 어떻게 소셜 로그인을 완성하는가

Grant Type 선택부터 PKCE 방어, Authorization Code 10단계 흐름, JWT Resource Server 검증까지 — Spring Security OAuth2의 설계 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Observability Deep Dive · 1

Observability는 왜 Monitoring과 다른가

임계값 알림이 답하지 못하는 Unknown Unknowns부터 메트릭/로그/트레이스 세 기둥의 역할 분담, OTel 표준화, 계측 방법론까지 — 분산 시스템 관찰 가능성의 근본 구조를 추적한다.

DEV 2026.05.02 · 15 min Intermediate Msa Deep Dive · 7

MSA 운영의 핵심은 관찰 가능성이다

분산 추적의 Trace ID부터 RED 메트릭, 배포 전략, 카스케이드 장애 방지까지 — MSA를 운영 가능한 시스템으로 만드는 설계 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Elasticsearch Deep Dive · 6

Elasticsearch 운영의 모든 결정은 하나의 균형에서 나온다

샤드 크기 설계부터 ILM 생명주기, 힙 메모리 제한, 쓰기 최적화, 캐시 전략, 장애 복구까지 — Elasticsearch 운영의 핵심 트레이드오프를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Docker Deep Dive · 5

Docker Compose에서 Swarm까지, 어떻게 설계가 이어지는가

선언형 정의부터 멀티 호스트 오케스트레이션까지, Docker Compose와 Swarm의 공통 철학과 설계 결정을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Java Concurrency Deep Dive · 1

Java 스레드는 OS와 어떻게 연결되는가

1:1 커널 스레드 매핑의 비용부터 컨텍스트 스위칭, ThreadPoolExecutor 내부, 상태 머신, Graceful Shutdown까지 — Java 동시성의 물리적 기반을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Architecture Patterns Deep Dive · 6

패키지 구조는 왜 팀의 아키텍처를 결정하는가

레이어 기반 구조의 응집도 문제부터 Hexagonal 패키지 설계, Gradle 멀티 모듈로 의존성을 컴파일 시점에 강제하고 ArchUnit으로 자동 검증하는 전략까지.

DEV 2026.05.02 · 12 min Intermediate Spring Boot Internals · 7

Spring Boot 앱은 어떻게 실행되는가

Fat JAR의 중첩 ClassLoader 구조부터 Native Image의 Closed World 가정, Kubernetes 운영 설정까지 — 배포 파이프라인 전체를 관통하는 설계 원리를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Batch Deep Dive · 5

Spring Batch Partitioning은 어떻게 1,000만 건을 나누는가

Manager-Worker 분리 구조부터 Remote Partitioning의 메시지 큐 분산까지, Partitioning의 설계 철학과 성능 한계를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Mysql Deep Dive · 2

MySQL 파티셔닝은 언제 써야 하는가

인덱스 대체라는 오해부터 프루닝 조건, 로컬 인덱스의 함정, 운영 DDL 비용까지 — MySQL 파티셔닝의 설계 결정을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Linux For Backend Deep Dive · 7

Linux 운영 지표, 숫자 뒤의 원인을 어떻게 읽는가

top의 us/sy/wa부터 소켓 상태, iostat, strace, perf Flame Graph까지 — 백엔드 서버 병목의 실체를 커널 수준에서 추적한다.

DEV 2026.05.02 · 14 min Intermediate Docker Deep Dive · 9

컨테이너 패턴의 통일된 철학은 무엇인가

Microservices부터 Graceful Shutdown까지, 8개 챕터를 관통하는 하나의 원칙 — '관심사 분리를 컨테이너 경계로 구현하라'를 추적한다.

DEV 2026.05.02 · 15 min Intermediate Kafka Deep Dive · 5

Kafka 처리량은 어디서 결정되는가

Producer 배치 전략부터 Consumer Fetch 튜닝, 파티션 핫스팟 진단, 운영 장애 대응까지 — Kafka 처리량을 지배하는 설계 결정들을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Rabbitmq Deep Dive · 5

RabbitMQ 운영의 모든 실패는 어디서 오는가

처리량 병목부터 Flow Control, 모니터링 맹점, 운영 장애 패턴, 클러스터 복구까지 — RabbitMQ 실무 운영의 다섯 가지 핵심 축을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Grpc Deep Dive · 7

REST에서 gRPC로 — 점진적 전환의 설계 원칙

모니터링부터 분산 추적, 연결 튜닝, 성능 비교, 마이그레이션까지 gRPC 운영의 핵심 패턴을 하나의 관통 철학으로 추적한다.

DEV 2026.05.02 · 13 min Intermediate Database Internals · 6

DB 성능 문제는 어디서 시작되는가

Slow Query 분석부터 N+1 탐지, 페이징 함정, 파티셔닝 설계, Connection Pool 튜닝까지 — DB 성능 저하의 다섯 가지 뿌리를 하나의 흐름으로 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Webflux Deep Dive · 7

WebFlux는 언제 써야 하고 언제 쓰지 말아야 하는가

I/O 집약 고동시성 환경에서 WebFlux가 MVC를 압도하는 조건부터, 블로킹 의존성·팀 역량·도메인 복잡도가 만드는 함정까지, 도입 판단의 기준을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Jvm Deep Dive · 8

JVM 튜닝의 철학 — 덜 건드릴수록 더 잘 돌아간다

플래그 분류부터 힙 산정 공식, GC Ergonomics, 프로파일링, 메모리 누수 추적, JMH 벤치마킹까지 — JVM 성능 최적화의 원칙을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Postgresql Deep Dive · 7

PostgreSQL 운영에서 설정이 먼저인가, 진단이 먼저인가

postgresql.conf 메모리 설정의 원리부터 pg_stat_statements 기반 진단, 인덱스 Bloat 해소, Long Transaction 차단, Spring HikariCP 최적화까지 — PostgreSQL 운영의 다섯 레이어를 하나의 흐름으로 추적한다.

DEV 2026.05.02 · 12 min Intermediate Docker Deep Dive · 7

Docker 컨테이너 리소스 관리의 철학

CPU shares·quota·cpuset부터 메모리 OOM Score·Swap 전략까지, cgroup 기반 리소스 격리가 '예측 가능한 멀티 테넌시'를 어떻게 구현하는지 추적한다.

DEV 2026.05.02 · 16 min Intermediate Cicd Deep Dive · 1

CI/CD는 자동화 도구인가, 운영 철학인가

수동 배포의 3대 구조적 실패부터 GitOps의 지속적 수렴 원칙까지, 코드가 프로덕션에 도달하는 전 과정을 신뢰 가능하게 만드는 설계를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Kubernetes Deep Dive · 2

쿠버네티스 파드는 어떻게 태어나고 사라지는가

kubectl apply부터 컨테이너 Running까지, 스케줄링 알고리즘과 containerd 실행, preStop Hook을 통한 무중단 종료까지 파드 생명주기 전체를 추적한다.

DEV 2026.05.02 · 16 min Intermediate Linux For Backend Deep Dive · 1

Linux 프로세스 모델은 왜 이렇게 설계됐는가

주소 공간 레이아웃과 PCB부터 CoW, 스레드 모델, 컨텍스트 스위칭, 시그널, CFS 스케줄러까지 — 백엔드 개발자가 알아야 할 리눅스 프로세스 설계 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Postgresql Deep Dive · 1

PostgreSQL은 왜 연결마다 프로세스를 fork하는가

연결당 프로세스 fork가 만드는 메모리 구조부터 MVCC의 Heap 내부 버전, WAL의 단일 로그 철학, XID Wraparound까지 — PostgreSQL 설계 결정의 공통 뿌리를 추적한다.

DEV 2026.05.02 · 16 min Intermediate Observability Deep Dive · 4

Prometheus는 왜 Pull 방식인가

Pull 스크레이프가 서비스 생존 감지를 내장하는 원리부터 카디널리티 폭발, Gorilla 압축, PromQL 계산 원리까지 — Prometheus 설계 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Spring Webflux Deep Dive · 2

WebFlux의 모든 설계는 하나의 질문에서 시작된다

Mono/Flux의 지연 평가부터 Backpressure 전략, Reactor Context까지 — WebFlux가 왜 이 방식으로 동작하는지, 그 근본 원리를 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Boot Internals · 3

Spring Boot 설정은 어떻게 주입되는가

application.yml 로딩 시점부터 Relaxed Binding, record 기반 불변 설정, PropertySource 우선순위 17단계까지, Spring Boot 설정 주입 메커니즘 전체를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Grpc Deep Dive · 2

Protobuf은 왜 JSON보다 작고 빠른가

Tag-Length-Value 인코딩부터 스키마 진화의 호환성 규칙까지, Protobuf의 설계 결정이 만들어내는 성능과 안전성의 근거를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Elasticsearch Deep Dive · 4

Elasticsearch는 왜 같은 조건도 다르게 처리하는가

Query Context와 Filter Context의 내부 분기부터 BM25 수식, 분산 IDF 편차, HNSW 벡터 검색까지, Elasticsearch 검색 파이프라인의 설계 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Mysql Deep Dive · 1

MySQL 쿼리 최적화의 공통 원리 — 인덱스를 죽이는 패턴들

서브쿼리 반복 실행부터 묵시적 형변환까지, MySQL Optimizer가 인덱스를 포기하는 조건과 실행계획을 읽어 수치로 개선하는 방법론을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Database Internals · 3

MySQL은 SQL을 어떻게 실행하는가

Parse Tree부터 Handler_read_* 변수까지, MySQL 쿼리 실행의 다섯 단계와 Cost-Based Optimizer의 판단 근거, 그리고 그 판단이 틀리는 이유를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Spring Data Transaction · 4

Spring Data JPA의 쿼리 전략은 왜 이렇게 많은가

JPQL 파싱 경로부터 N+1 해소 전략, 페이징 함정, QueryPlanCache 최적화, 2차 캐시까지 — Spring Data JPA의 모든 쿼리 결정이 공유하는 하나의 원칙을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Webflux Deep Dive · 5

WebFlux에서 JPA를 쓰면 왜 성능이 오히려 나빠지는가

JPA의 블로킹 JDBC가 EventLoop를 점유하는 원리부터 R2DBC의 논블로킹 구조, Reactor Context 기반 트랜잭션, N+1 해결 패턴까지 WebFlux 데이터 계층의 설계 결정을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Rabbitmq Deep Dive · 6

RabbitMQ vs Kafka — 어떤 문제를 해결하려고 만들어졌는가

메시지 전달 후 삭제하는 브로커와 이벤트를 로그로 영구 보관하는 분산 로그의 철학적 차이부터, Push/Pull 소비 방식과 두 시스템을 함께 쓸 때의 아키텍처 분리까지 추적한다.

DEV 2026.05.02 · 15 min Intermediate Spring Webflux Deep Dive · 1

WebFlux는 왜 스레드를 8개만 쓰는가

Thread-per-Request 모델이 I/O 앞에서 무너지는 이유부터 epoll 이벤트 루프, Reactive Streams 스펙, 그리고 WebFlux vs MVC 선택 기준까지 하나의 흐름으로 추적한다.

DEV 2026.05.02 · 14 min Intermediate Cqrs Event Sourcing Deep Dive · 4

CQRS 프로젝션은 왜 Kafka Consumer처럼 동작하는가

이벤트 스트림을 읽기 모델로 변환하는 프로젝션의 내부 동작부터 Blue/Green 재구축, 장애 격리, Eventual Consistency 처리까지 하나의 설계 철학을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Java Concurrency Deep Dive · 7

Java 동시성 버그는 왜 재현이 어려운가

데드락 4가지 조건부터 Lock Contention 진단, Virtual Thread와 Spring 어노테이션의 스레드 모델 오해까지, Java 동시성 버그의 구조적 원인을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Ddd Deep Dive · 6

DDD는 왜 경계부터 그리는가

Bounded Context 식별부터 Aggregate 불변식, 이벤트 기반 통합, CQRS 읽기 모델, 레거시 점진적 전환까지 — 전자상거래 도메인으로 DDD 설계 결정을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Cqrs Event Sourcing Deep Dive · 7

CQRS와 Event Sourcing, 언제 쓰고 언제 피해야 하는가

은행 계좌 도메인의 완전 구현부터 안티패턴 진단, 점진적 도입 로드맵, 실제 비용과 편익까지 — CQRS/ES 도입 결정을 위한 실전 분석.

DEV 2026.05.02 · 13 min Intermediate Docker Deep Dive · 12

Docker로 Full-stack 서비스를 운영한다는 것은 무엇인가

웹 앱 컨테이너화부터 데이터베이스 영속성, Reverse Proxy, 모니터링, 로그 집계, 백업, 다층 아키텍처까지 — Docker 기반 프로덕션 스택의 설계 철학을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Architecture Patterns Deep Dive · 7

레거시를 죽이지 않고 교체하는 법

진단 없는 리팩터링이 왜 실패하는지부터 Strangler Fig로 도메인·인프라 레이어를 단계적으로 분리해 테스트 속도를 10배 높이는 과정까지, 아키텍처 전환의 현실을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Java Api Reference · 13

Java Reflection은 어떻게 프레임워크를 만드는가

런타임 클래스 조작의 원리부터 Dynamic Proxy, Annotation 처리, 성능 최적화까지 — Spring·JPA가 Reflection 위에서 동작하는 방식을 추적한다.

DEV 2026.05.02 · 14 min Intermediate System Design Deep Dive · 6

시스템은 어떻게 실패하지 않는가

장애 전파 차단부터 분산 트랜잭션의 보상 로직, SLO 기반 에러 버짓, DR 전략의 비용 트레이드오프, 그리고 Blameless 문화까지 — 운영 가능한 시스템을 만드는 다섯 가지 원칙을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Kafka Deep Dive · 2

Kafka는 어떻게 메시지를 잃지 않는가

파티션 복제의 Leader/Follower 구조부터 ISR, acks, min.insync.replicas, Leader Election, Log Compaction까지 — Kafka 내구성 설계의 일관된 철학을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Postgresql Deep Dive · 6

PostgreSQL 복제는 하나의 철학이다

WAL 스트리밍부터 Logical Decoding, Patroni Split-Brain 방지, PgBouncer Transaction Mode까지 — PostgreSQL 복제 생태계 전체를 관통하는 설계 원칙을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Database Internals · 7

MySQL 복제는 어떻게 일관성을 지키는가

Binary Log 3단계 복제 구조부터 GTID 기반 자동 페일오버, Spring AbstractRoutingDataSource 구현까지 — 비동기 복제의 구조적 특성과 그 대가를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Mysql Deep Dive · 3

MySQL Replication은 왜 '보낸 것'과 '도착한 것'이 다른가

비동기 복제의 구조적 지연부터 Binary Log 포맷, GTID Failover, Semi-Sync, 병렬 복제, Spring 라우팅까지 — 복제 파이프라인 전체를 하나의 트레이드오프 지도로 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Mvc Deep Dive · 2

Spring MVC는 요청을 어떻게 핸들러에 연결하는가

애플리케이션 시작 시 @RequestMapping을 스캔해 MappingRegistry에 등록하는 과정부터, URL 패턴 매칭·조건 평가·URI 변수 추출까지 요청 라우팅의 전 과정을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Kubernetes Deep Dive · 5

Kubernetes는 자원을 어떻게 나누고 지키는가

cgroups 구현부터 QoS 클래스, HPA·VPA·클러스터 오토스케일러까지, Kubernetes 자원 관리 철학의 층위를 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Mvc Deep Dive · 4

Spring MVC는 반환값을 어떻게 HTTP 응답으로 바꾸는가

ReturnValueHandler 체인부터 HttpMessageConverter 선택, Content Negotiation 알고리즘, 커스텀 핸들러 작성까지 — 컨트롤러 반환값이 HTTP 응답이 되는 전 과정을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Db Migration Deep Dive · 4

DB 마이그레이션은 왜 되돌릴 수 없는가

MySQL DDL의 암묵적 COMMIT부터 Forward-Only 전략, Flyway Undo의 한계, 실패 복구 절차, 백업까지 — 마이그레이션이 일방통행인 이유를 추적한다.

DEV 2026.05.02 · 15 min Advanced Jvm Deep Dive · 2

JVM은 메모리를 어떻게 나누는가

Heap의 세대별 구조부터 TLAB, 스택 프레임, Metaspace, Runtime Constant Pool, 객체 레이아웃, Off-Heap까지 JVM 메모리 모델 전체를 하나의 설계 철학으로 추적한다.

DEV 2026.05.02 · 14 min Intermediate Msa Deep Dive · 4

MSA에서 분산 트랜잭션을 어떻게 다룰 것인가

2PC의 가용성 함정부터 Saga의 보상 트랜잭션 설계, 멱등성 보장, Dead Saga 감지까지 — MSA 일관성의 실전 패턴을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Mysql Deep Dive · 5

MySQL 설계 결정은 왜 처음이 전부인가

데이터 타입 선택부터 정규화 수준, AUTO_INCREMENT 전략, 운영 중 스키마 변경까지 — 되돌리기 어려운 MySQL 설계 결정의 핵심 원칙을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Db Migration Deep Dive · 1

스키마도 코드다 — DB 마이그레이션은 왜 필수인가

수동 DDL 실행이 팀 단위에서 반드시 무너지는 이유부터, Flyway 내부 추적 메커니즘과 ddl-auto=update의 위험, 환경별 전략까지 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Security Deep Dive · 1

Spring Security의 요청 처리 구조는 어떻게 설계되어 있는가

DelegatingFilterProxy의 브릿지 역할부터 SecurityContextHolder의 ThreadLocal 기반 인증 전파까지, Spring Security의 핵심 설계 결정을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Grpc Deep Dive · 5

gRPC 보안은 왜 계층으로 쌓는가

TLS 핸드쉐이크부터 mTLS 클라이언트 인증, JWT Interceptor, SPIFFE 기반 서비스 신원까지 — gRPC 보안 계층이 Zero Trust 아키텍처로 수렴하는 이유를 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Webflux Deep Dive · 6

Spring WebFlux Security는 왜 다시 배워야 하는가

MVC Security의 ThreadLocal 기반 설계가 Reactor Context로 대체되는 과정부터, JWT 필터 체인·Method Security·OAuth2 Client Credentials 흐름까지, Reactive Security 전체를 관통하는 설계 원칙을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Security Engineering Deep Dive · 7

보안은 도구가 아니라 파이프라인이다

SAST, DAST, 침투 테스트, 보안 로깅, 인시던트 대응까지 — 코드가 배포되기 전부터 사고가 난 뒤까지, 보안 엔지니어링의 전체 흐름을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Mysql Deep Dive · 7

MySQL 보안 설계의 세 기둥 — 권한, 연결, 환경 분리

최소 권한 원칙과 Role 기반 권한 관리부터 SSL/TLS 강제, 데이터 마스킹을 통한 환경 분리까지, MySQL 운영 보안의 핵심 구조를 추적한다.

DEV 2026.05.02 · 12 min Intermediate Docker Deep Dive · 6

Docker 보안은 왜 여러 계층이 필요한가

단일 보안 설정으로 충분하지 않은 이유부터 Seccomp·Capabilities·User Namespace·Secrets 관리까지, Docker Defense in Depth의 설계 논리를 추적한다.

DEV 2026.05.02 · 17 min Intermediate Security Engineering Deep Dive · 1

보안 설정을 켰다고 안전한 게 아니다

공격자가 빠진 것을 찾는 방식부터 STRIDE 위협 분류, DFD 신뢰 경계, Defense in Depth, SDL 통합까지 — 공격자 관점 설계의 전체 구조를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Msa Deep Dive · 1

MSA는 왜 도입하는가 — 모놀리스가 무너지는 시점

모놀리스의 배포 결합·확장 비효율부터 분산 모놀리스 안티패턴, Conway's Law와 서비스 자율성까지, MSA 도입 결정의 근거를 추적한다.

DEV 2026.05.02 · 15 min Intermediate Grpc Deep Dive · 3

gRPC를 제대로 쓴다는 것의 의미

proto 설계 원칙부터 에러 처리, 메타데이터, Deadline 전파, 로드밸런싱, Schema Registry까지 — gRPC 시스템이 실제로 무너지는 지점을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Cloud Deep Dive · 2

Eureka는 왜 AP를 선택했는가

DNS의 한계부터 Self-Preservation까지, Spring Cloud Eureka의 서비스 디스커버리 설계 결정을 내부 구조와 함께 추적한다.

DEV 2026.05.02 · 14 min Intermediate Spring Security Deep Dive · 4

Spring Security 세션 관리의 네 가지 레이어

Session Fixation 방어부터 동시 세션 제어, 타임아웃 처리, Stateless 전환까지 — Spring Security가 세션 생명주기 전체를 어떻게 감시하는지 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Core Deep Dive · 8

Spring의 타입 변환 시스템은 어떻게 작동하는가

SpEL 파싱 파이프라인과 ${...}/#{...} 처리 경로의 차이부터 PropertyEditor·Converter·GenericConverter 세 계층의 협력 구조까지, Spring Core의 값 주입 철학을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Rabbitmq Deep Dive · 7

Spring AMQP의 컴포넌트들은 어떻게 연결되는가

RabbitTemplate의 Channel 재사용 원리부터 SMLC/DMLC 선택, 직렬화 타입 별칭, 재시도 전략, Testcontainers 통합 테스트까지, Spring AMQP 전체 설계를 관통하는 계층 구조를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Cqrs Event Sourcing Deep Dive · 6

Axon과 순수 Spring으로 배우는 CQRS+ES 설계 결정

어노테이션 뒤에 숨은 CommandBus, EventStore, Tracking Processor의 동작 원리부터, Axon 없이 직접 구현했을 때 드러나는 CQRS의 본질까지 추적한다.

DEV 2026.05.02 · 14 min Intermediate Spring Data Transaction · 1

Spring Data JPA는 인터페이스 선언만으로 어떻게 동작하는가

Repository 프록시 생성부터 Query Method 파싱, Projection 최적화, Custom Repository 합성까지 — Spring Data JPA의 설계 철학을 내부 소스로 추적한다.

DEV 2026.05.02 · 15 min Intermediate Elasticsearch Deep Dive · 7

Spring + Elasticsearch, 어디서 무엇이 깨지는가

매핑 어노테이션의 변환 원리부터 인덱싱 전략, 쿼리 선택, 무중단 재인덱싱까지 — Spring Data Elasticsearch 실전 운영의 핵심 설계 결정을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Grpc Deep Dive · 6

Spring에서 gRPC를 제대로 쓰려면 무엇이 필요한가

설정 자동화부터 보안 컨텍스트 전파, 예외 매핑, Reactive 통합, 테스트 격리까지 — grpc-spring-boot-starter의 전체 동작 원리를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Db Migration Deep Dive · 7

DB 마이그레이션을 안전하게 배포하려면 무엇이 필요한가

Spring Boot + Flyway 자동 설정의 함정부터 대용량 배치 처리, Dark Launch, 실전 케이스 스터디까지 — 프로덕션 마이그레이션의 핵심 패턴을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Spring Data Transaction · 5

JdbcTemplate이 JDBC 보일러플레이트를 제거하는 방법

Connection 획득부터 예외 변환, 결과 매핑, 배치 처리까지 — JdbcTemplate 패밀리의 설계 철학과 트레이드오프를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Ddd Deep Dive · 5

DDD와 JPA는 왜 긴장 관계인가

Persistence Ignorance 원칙부터 Repository 패턴, AbstractAggregateRoot, 테스트 전략까지 — 도메인 설계가 JPA의 제약을 어떻게 극복하는지 추적한다.

DEV 2026.05.02 · 12 min Intermediate Kafka Deep Dive · 7

Spring Kafka는 왜 그렇게 설계되었는가

KafkaTemplate 비동기 전송의 함정부터 Outbox Pattern까지, Spring Kafka 5개 레이어를 관통하는 하나의 질문 — '정확히 한 번'은 가능한가.

DEV 2026.05.02 · 11 min Intermediate Observability Deep Dive · 7

Observability는 왜 세 신호가 함께여야 하는가

메트릭, 트레이스, 로그가 분리되면 증상만 보인다. Spring Boot Actuator 자동 구성부터 Kubernetes 네이티브 배포, 실전 장애 진단까지 세 신호의 연결 원리를 추적한다.

DEV 2026.05.02 · 11 min Intermediate Spring Webflux Deep Dive · 4

WebFlux 아키텍처는 왜 이렇게 설계됐는가

DispatcherHandler의 Reactive 위임 구조부터 WebClient 병렬 호출, SSE/WebSocket 스트리밍, WebFilter 불변 패턴까지 — WebFlux 설계 철학의 일관된 흐름을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Security Engineering Deep Dive · 6

서버가 공격자의 손이 되는 순간 — Spring 보안 설계의 5가지 원칙

SSRF부터 의존성 취약점까지, 클라우드 시대의 Spring 애플리케이션이 마주하는 공격 패턴과 그 방어 설계를 관통하는 하나의 질문을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Database Internals · 1

InnoDB는 왜 데이터를 Page 단위로 읽고 쓰는가

16KB Page부터 WAL까지, InnoDB의 모든 물리 저장 결정이 하나의 원칙 — I/O 비용 최소화 — 에서 비롯됨을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Boot Internals · 1

SpringApplication.run()은 한 줄인데 내부에서 무슨 일이 벌어지는가

웹 타입 감지부터 내장 서버 포트 바인딩까지, Spring Boot 시작 과정의 설계 철학과 각 단계의 역할을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Docker Deep Dive · 4

Docker 스토리지는 어디서 끝나고 어디서 시작되는가

컨테이너의 일시성과 데이터의 영속성이 충돌하는 지점부터 볼륨 드라이버, 스토리지 드라이버, 백업 전략까지 — Docker 스토리지 설계의 통일된 원칙을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Kubernetes Deep Dive · 4

쿠버네티스 스토리지는 왜 이렇게 복잡한가

emptyDir 수명부터 CSI 볼륨 마운트 3단계, StatefulSet의 안정적 ID 보장, 그리고 스토리지 선택이 DB 성능을 결정하는 이유까지 추적한다.

DEV 2026.05.02 · 14 min Intermediate Ddd Deep Dive · 2

DDD는 어디서 경계를 긋는가

서브도메인 분류부터 Bounded Context, Ubiquitous Language, Context Map 패턴, ACL, 이벤트 스토밍, 마이크로서비스까지 — DDD의 전략적 설계가 공유하는 하나의 질문을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Grpc Deep Dive · 4

gRPC 스트리밍은 왜 Polling보다 효율적인가

Server Streaming의 HTTP/2 Frame 흐름부터 Bidirectional의 Half-close, Flow Control의 Window Size 튜닝, 그리고 Exponential Backoff 재연결까지, gRPC 스트리밍의 설계 철학을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Java Api Reference · 1

Java String은 왜 불변인가

String 불변성의 설계 근거부터 String Pool의 메모리 구조, StringBuilder의 성능 원리, 그리고 실전 패턴의 공통 철학까지, Java 문자열의 모든 결정을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Java Design Patterns · 2

구조 패턴의 공통 문법 — 상속 대신 관계로 설계하라

Adapter부터 Flyweight까지, Java 구조 패턴 7개가 공유하는 하나의 철학 — 상속 계층을 포기하고 객체 간 관계로 복잡성을 제어하는 방법을 추적한다.

DEV 2026.05.02 · 13 min Intermediate Ddd Deep Dive · 3

DDD의 모든 패턴은 하나의 질문에서 나온다

Entity/Value Object 구분부터 Aggregate 경계, Repository 설계, Domain Event까지 — DDD 전술 패턴들이 공유하는 하나의 원칙을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Db Migration Deep Dive · 5

마이그레이션 버전 충돌은 왜 배포 직전까지 보이지 않는가

두 개발자가 동시에 같은 버전 번호를 생성하는 순간부터 MSA의 Database per Service 분리까지, DB 마이그레이션 전략의 핵심 결정들을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Network Deep Dive · 2

TCP가 선택한 것들 — 연결, 신뢰성, 흐름, 혼잡, 그리고 UDP

3-Way Handshake가 3번인 이유부터 CLOSE_WAIT가 서버를 죽이는 메커니즘까지, TCP 설계 철학의 일관된 패턴을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Unit Testing · 6

테스트 코드가 프로덕션을 오염시키는 일곱 가지 방법

if (isTest) 분기부터 Assertion Roulette까지, 테스트 안티패턴의 근본 원인과 설계 교정을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Cicd Deep Dive · 6

CI/CD 파이프라인은 왜 느려지는가

테스트 피라미드 배치부터 컨텍스트 재사용, 품질 게이트, 성능 회귀 감지, 보안 스캐닝까지 — 파이프라인 설계의 다섯 가지 결정을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Performance Testing Deep Dive · 1

성능 테스트는 왜 유형이 다른가

Load / Stress / Spike / Soak 테스트가 각각 다른 질문에 답하는 이유부터, SLO 기반 p99 목표 설정과 Baseline 자동화를 통한 회귀 감지까지 추적한다.

DEV 2026.05.02 · 13 min Intermediate Unit Testing · 4

테스트하기 어렵다는 느낌은 설계 냄새다

의존성 주입부터 Hexagonal Architecture까지, 테스트 가능한 설계의 공통 원칙과 각 패턴이 어떻게 같은 철학을 다른 방식으로 표현하는지 추적한다.

DEV 2026.05.02 · 13 min Intermediate Spring Data Transaction · 7

Spring Data 테스트는 왜 이렇게 설계됐는가

@DataJpaTest 슬라이스 컨텍스트의 제약부터 Testcontainers 컨테이너 공유 전략까지, Spring 데이터 계층 테스트의 설계 철학을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Unit Testing · 1

좋은 단위 테스트란 무엇인가

단위의 정의부터 FIRST 원칙까지, 테스트가 팀의 짐이 아닌 자산이 되기 위한 설계 결정들을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Elasticsearch Deep Dive · 3

Elasticsearch는 어떻게 텍스트를 이해하는가

분석 파이프라인의 3단계 구조부터 Nori 형태소 분석, 동의어·n-gram 커스텀 설계, 매핑 폭발 방지, Analyzer 불일치 디버깅까지, 검색 품질의 뿌리를 추적한다.

DEV 2026.05.02 · 16 min Intermediate Network Deep Dive · 4

HTTPS는 어떻게 안전한가 — TLS의 설계 철학

대칭키와 비대칭키의 조합부터 인증서 체인 검증, mTLS 기반 Zero Trust까지, TLS가 신뢰를 구축하는 방식을 추적한다.

DEV 2026.05.02 · 15 min Intermediate Postgresql Deep Dive · 4

PostgreSQL은 8KB 페이지를 어떻게 넘는가

TOAST부터 JSONB 바이너리 포맷, 배열 GIN 인덱스, 전문 검색, Large Object까지 — PostgreSQL의 대용량 값 저장 철학을 추적한다.

DEV 2026.05.02 · 14 min Intermediate Spring Data Transaction · 2

Spring 트랜잭션은 어떻게 비즈니스 코드를 깨끗하게 유지하는가

PlatformTransactionManager 추상화부터 Propagation 7가지, Isolation Level, readOnly 최적화, Rollback 규칙, afterCommit 훅까지 — Spring 트랜잭션 설계 철학의 일관된 원리를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Database Internals · 4

ACID는 누가 보장하는가

Undo Log부터 Gap Lock까지, InnoDB가 ACID 네 글자를 각각 다른 메커니즘으로 구현하는 방식과 그 상호작용을 추적한다.

DEV 2026.05.02 · 12 min Intermediate Performance Testing Deep Dive · 6

성능 튜닝은 과학이다 — 하나씩, 측정하고, 번역하라

변수 격리 원칙부터 p99 비즈니스 번역, CI 자동화, 실전 DB 커넥션 고갈 케이스까지, 성능 튜닝을 반복 가능한 과학으로 만드는 방법을 추적한다.

DEV 2026.05.02 · 11 min Intermediate Java Api Reference · 10

Java Util API의 공통 철학: 비교, 흐름, 부재, 패턴

Comparator의 체이닝부터 Stream 파이프라인, Optional의 null 추방, 정규표현식의 패턴 추상화까지 — Java util 패키지가 반복하는 하나의 설계 언어를 추적한다.

DEV 2026.05.02 · 13 min Intermediate Java Concurrency Deep Dive · 6

Virtual Thread는 왜 OS 스레드의 한계를 넘는가

Thread-per-Request 모델의 처리량 상한선부터 Pinning·ThreadLocal 함정까지, Java 21 Virtual Thread의 설계 원리와 실전 함의를 추적한다.

DEV 2026.05.02 · 14 min Intermediate Security Engineering Deep Dive · 4

XSS부터 Clickjacking까지, 웹 보안 헤더의 설계 철학

Reflected·Stored·DOM-based XSS의 공격 원리부터 CSP Nonce, HSTS, Permissions-Policy, Open Redirect 방어까지, 브라우저와 서버가 신뢰를 구축하는 방식을 추적한다.

DEV 2026.05.02 · 16 min Intermediate Cqrs Event Sourcing Deep Dive · 1

CQRS는 왜 필요한가 — 단일 모델이 붕괴되는 과정

JPA 단일 Entity가 쓰기와 읽기를 동시에 담당할 때 발생하는 임피던스 불일치부터, 세 가지 수준의 CQRS 스펙트럼과 적용 판단 기준까지 추적한다.

DEV 2026.05.02 · 12 min Intermediate Db Migration Deep Dive · 3

DDL 마이그레이션, 왜 이렇게 어려운가

Lock 메커니즘부터 Expand-Contract 패턴, 외래 키 전략까지 — 프로덕션 DB 스키마 변경이 서비스를 멈추는 이유와 그것을 피하는 방법을 추적한다.

DEV 2026.04.27 · 15 min Intermediate Redis Deep Dive · 5

Redis의 모든 선택은 하나의 질문에서 나온다

캐싱 전략 선택부터 분산 락 논쟁까지, Redis를 올바르게 쓰기 위해 반드시 답해야 할 트레이드오프 질문들을 추적한다.

DEV 2026.04.27 · 12 min Intermediate Redis Deep Dive · 2

Redis는 왜 같은 데이터를 다르게 저장하는가

String의 SDS부터 Sorted Set의 skiplist까지, Redis 7가지 자료구조의 인코딩 전략과 listpack 경계가 메모리를 10배 바꾸는 원리를 추적한다.

DEV 2026.04.27 · 13 min Intermediate Redis Deep Dive · 6

Redis 운영의 모든 병목은 단일 스레드에서 시작된다

SLOWLOG 진단부터 Lua 원자성, 메모리 인코딩, 모니터링 지표, OOM·복제·fork 장애 패턴까지, Redis 운영 지식의 공통 뿌리를 추적한다.

DEV 2026.04.27 · 14 min Intermediate Redis Deep Dive · 3

Redis 영속성은 어떻게 설계하는가

BGSAVE의 fork() Copy-On-Write 원리부터 AOF fsync 정책, 혼합 포맷, 장애 복구, 서비스별 최적 설정까지 — Redis 영속성의 모든 트레이드오프를 추적한다.

DEV 2026.04.27 · 13 min Intermediate Redis Deep Dive · 1

Redis의 모든 설계 결정은 하나의 철학에서 나온다

단일 스레드 이벤트 루프부터 jemalloc 메모리 관리, redisObject 인코딩, 키 만료 메커니즘, Threaded I/O까지 — Redis 내부 설계의 공통 원리를 추적한다.

DEV 2026.04.27 · 12 min Intermediate Redis Deep Dive · 4

Redis 복제는 왜 데이터를 잃는가

비동기 복제의 구조적 한계부터 PSYNC backlog 계산, Sentinel Failover, Cluster 리샤딩, WAIT 명령어까지 — Redis 고가용성 설계의 트레이드오프를 추적한다.

DEV 2026.04.27 · 12 min Intermediate Redis Deep Dive · 7

Spring + Redis 통합에서 직렬화가 모든 것을 결정한다

JDK 직렬화 기본값이 왜 금지 수준인지부터 @Cacheable AOP 체인, Redis 세션 구조, Redisson 분산 락까지, Spring-Redis 통합의 핵심 설계 결정을 추적한다.