KNOWLEDGE · CATEGORIES
지식 · 카테고리
지식형 글만 모아 카테고리별로 정리한 페이지입니다.
AI
맨 처음 ↓- 사고 예산 제어: 얼마나 생각하게 할 것인가 NEW
- 검증자 모델: 답을 고르는 눈을 따로 기른다 NEW
- 추론 능력은 어떻게 훈련되는가: 검증 가능한 보상과 강화학습 NEW
- 테스트 타임 컴퓨트: 추론 시점에 계산을 더 쓴다는 것 NEW
- 추론 모델은 무엇이 다른가: 사고 토큰과 그 청구서 NEW
- LLM 비용 최적화: 더 저렴하게, 더 빠르게
- LLM 서비스 배포: API 서버부터 모니터링까지
- 프롬프트 반복 개발: 체계적인 이터레이션 워크플로우
- 평가 하네스 구축: LLM 성능을 체계적으로 측정하라
- 파인튜닝 파이프라인 구축: 데이터부터 배포까지
- 에이전트 시스템 처음부터 구축하기: 실전 프로젝트
- RAG 시스템 처음부터 구축하기: 실전 프로젝트
- GPU 메모리 최적화: OOM 없이 더 크게 훈련하는 법
- GPU와 CUDA: 딥러닝 연산의 심장을 이해하다
- Jupyter Notebook·Lab 완전 정복: AI 개발자의 필수 환경
- Google Gemini SDK 활용 가이드
- OpenAI SDK 완전 정복
- Anthropic SDK로 Claude API 활용하기
- HuggingFace Hub: 모델 공유와 배포
- HuggingFace Datasets로 데이터 관리하기
- HuggingFace Transformers 실전 가이드
- TensorFlow/Keras로 시작하는 딥러닝
- PyTorch 학습 루프 완전 정복
- PyTorch 기초: 텐서와 자동미분
- AI 개발을 위한 Python 핵심 라이브러리
- AI 회의 요약 시스템: 음성 인식부터 인사이트 추출까지
- AI 폼·서류 자동화: OCR부터 자동 입력까지
- AI 번역 시스템 구축: 도메인 특화 고품질 번역
- AI 정보 추출 파이프라인: 비정형 데이터에서 구조화 데이터로
- AI 데이터 분석 보조 시스템
- AI 콘텐츠 생성 자동화 파이프라인
- AI 고객 지원 자동화: 티켓 분류부터 답변 생성까지
- 사내 지식 검색 시스템 구축
- 문서 Q&A 시스템 구축: RAG 기반 PDF·문서 검색
- AI 챗봇 서비스 설계: 아키텍처부터 배포까지
- AI로 코드 리뷰하기: 자동화와 사람 리뷰의 균형
- AI 코딩 모범 사례: 생산성과 품질을 동시에 잡는 전략
- Aider: AI 페어 프로그래머와 Git 통합 개발
- OpenAI Codex와 ChatGPT: AI 코딩의 시작점
- Claude Code: 터미널에서 만나는 AI 소프트웨어 엔지니어
- Cursor: AI 네이티브 IDE의 새로운 기준
- AI 코딩 도구의 시대: GitHub Copilot 완전 해부
- 데이터 중복 제거: 정확한 매칭부터 시맨틱 디덥까지
- 데이터 품질 관리: 쓰레기 in, 쓰레기 out을 막는 법
- 합성 데이터: 실제 데이터 없이 AI 학습 데이터 만들기
- 데이터 증강: 적은 데이터로 더 강한 모델 만들기
- 데이터 레이블링: AI가 학습할 정답을 만드는 과정
- 데이터 수집: AI 모델의 연료를 모으는 방법
- AI 규제: 전 세계 AI 법안과 거버넌스 현황
- AI 워터마킹: AI 생성 콘텐츠를 추적하는 기술
- AI 탈옥(Jailbreak): 공격 유형과 방어 전략
- AI와 프라이버시: 개인정보를 지키는 기술
- 설명 가능한 AI(XAI): 블랙박스를 열다
- AI 편향과 공정성: 알고리즘 차별을 막는 방법
- AI 정렬: 인간의 가치와 AI 목표를 일치시키기
- AI 안전성 개요: 신뢰할 수 있는 AI를 만들기 위한 기반
- LLM Fallback 전략: 장애에도 살아남는 서비스 설계
- LLM 시맨틱 캐시: 반복 요청 비용 제로화 전략
- LLM 비용 추적: 토큰 낭비 없이 운영하기
- LLMOps 관측성: 프로덕션 LLM 시스템 들여다보기
- LLM 평가 파이프라인: 자동화된 품질 보장
- LLM 프롬프트 관리: 버전, 테스트, 배포까지
- LLMOps 개요: LLM 운영의 새로운 과제
- ML 파이프라인 자동화: 끝까지 이어지는 워크플로우
- 데이터 버전 관리: DVC로 ML 데이터를 코드처럼 추적하기
- 모델 모니터링: 프로덕션 ML 감시
- ML CI/CD: 자동화된 모델 배포 파이프라인
- 모델 레지스트리: 모델 생애주기 관리
- 피처 스토어: 피처 재사용과 일관성 확보
- MLOps 실험 트래킹: 재현 가능한 ML 개발
- MLOps 완전 정복: 머신러닝을 프로덕션으로
- LLM 편향과 독성 평가
- 태스크별 맞춤 평가 지표 설계
- ELO 레이팅으로 LLM 순위 매기기
- LLM-as-Judge: AI가 AI를 평가하다
- LLM 인간 평가: 신뢰할 수 있는 정성 평가 설계하기
- LLM 벤치마크 완전 정리: MMLU부터 HumanEval까지
- RLHF 심화: 인간 피드백으로 LLM 정렬하기
- 액터-크리틱: 정책과 가치 함수의 시너지
- PPO: 안정적인 정책 최적화의 표준
- 정책 경사법: 정책을 직접 최적화하기
- DQN: 딥러닝으로 확장하는 Q-러닝
- Q-러닝: 테이블로 배우는 최적 행동 전략
- 강화학습 기초: 에이전트, 환경, 보상의 언어
- LLM 기반 추천 시스템: 언어 모델이 바꾸는 추천의 패러다임
- 투타워 모델: 대규모 추천 시스템 구조 완전 해설
- 딥러닝 추천 시스템: NCF·Wide&Deep·DIN 완전 해설
- 행렬 분해(MF): SVD·ALS·FunkSVD 추천 알고리즘 완전 해설
- 콘텐츠 기반 필터링: 아이템 특성으로 추천하는 방법 완전 해설
- 협업 필터링: 유사 사용자·아이템 기반 추천 완전 해설
- 멀티모달 AI 평가: MMBench·MMMU·VQA 벤치마크 완전 해설
- 비전-언어 모델(VLM): CLIP·BLIP2·LLaVA 완전 해설
- 멀티모달 LLM: 텍스트·이미지·오디오를 함께 이해하는 AI 완전 해설
- AI 음악 생성: MusicGen·AudioCraft·Suno AI 완전 해설
- 신경망 음성 합성(TTS): VITS·XTTS·CosyVoice 완전 해설
- 자동 음성 인식(ASR): Whisper와 스트리밍 음성 처리 완전 해설
- 3D 생성 AI: NeRF·3D Gaussian Splatting·Point-E 완전 해설
- 비디오 생성 모델: Sora·AnimateDiff·Stable Video Diffusion 완전 해설
- AI 이미지 편집: 인페인팅·아웃페인팅·스타일 전이·DDIM Inversion
- ControlNet: 포즈·깊이·엣지로 확산 모델을 정밀 제어하기
- Stable Diffusion: 잠재 확산 모델의 구조와 실전 활용
- 확산 모델(Diffusion Model) 기초: 노이즈에서 이미지로
- CLIP: 이미지와 텍스트를 같은 공간에 정렬하는 대조 학습
- Vision Transformer(ViT): 이미지를 문장처럼 처리하는 Transformer
- 딥러닝 이미지 분류 완전 정복: 백본·전이학습·실전 코드
- 에이전트 안티패턴: 흔한 실수와 피해야 할 설계
- 에이전트 평가: 성능 측정과 벤치마킹 방법론
- 에이전트 리플렉션: 자기 평가와 반복 개선 패턴
- 에이전트 플래닝: ReAct, Plan-and-Execute, Reflexion 전략
- 에이전트 메모리: 단기·장기·시맨틱 메모리 아키텍처
- OpenAI Swarm: 경량 멀티 에이전트 핸드오프 패턴
- AutoGen 완전 가이드: 대화 기반 멀티 에이전트 프레임워크
- CrewAI 완전 가이드: 역할 기반 멀티 에이전트 협업
- LlamaIndex 완전 가이드: 데이터 중심 LLM 프레임워크
- LangGraph 완전 가이드: 상태 기반 에이전트 워크플로우
- LangChain 완전 가이드: 에이전트 프레임워크의 표준
- MCP 프로토콜 심층: 서버 구현과 통합
- 에이전트 도구 사용: Tool Use 완전 가이드
- 에이전트 아키텍처: ReAct·Plan-and-Execute·Reflexion
- AI 에이전트와 MCP: 자율적으로 행동하는 AI 시스템
- LLM 서빙 비용 최적화: 토큰·GPU·캐싱 전략
- LLM API 속도 제한: Rate Limiting 전략과 구현
- LLM 스트리밍 완전 가이드: SSE부터 WebSocket까지
- LLM 서빙 API 설계: OpenAI 호환 인터페이스 구축
- KV 캐시 완전 해설: LLM 추론 메모리의 핵심
- LLM 추론 배치 전략: Continuous Batching과 KV 캐시 완전 해설
- TGI 완전 가이드: Hugging Face의 프로덕션급 LLM 서빙
- Ollama 완전 가이드: 로컬 LLM을 가장 쉽게 실행하기
- llama.cpp 완전 가이드: CPU에서 LLM 추론하기
- LLM 추론 엔진 완전 비교: vLLM·TGI·llama.cpp·Ollama
- 투기적 디코딩: LLM 추론 속도를 2~4배 높이는 기술
- 모델 프루닝: 신경망의 불필요한 가중치 제거하기
- 지식 증류: 대형 모델의 지식을 소형 모델로 이전하기
- AWQ vs GPTQ: 고급 INT4 양자화 완전 비교
- GGUF 완전 정복: llama.cpp의 양자화 포맷과 실전 사용법
- 양자화 완전 정복: 모델 크기를 절반으로 줄이는 기술
- 온프레미스에서 LLM 파인튜닝: GPU 서버 구성 완전 가이드
- 클라우드에서 LLM 파인튜닝: AWS·GCP·Azure 완전 가이드
- 파인튜닝 평가: 내 모델이 얼마나 좋아졌는지 측정하기
- 파인튜닝 하이퍼파라미터: 최적 설정 완전 가이드
- 파인튜닝 데이터 준비: 형식·품질·양 완전 가이드
- Adapter: 트랜스포머 레이어에 소형 모듈을 삽입하는 파인튜닝
- Prefix Tuning & P-Tuning: 접두사 토큰으로 LLM 조율하기
- QLoRA: 4비트 양자화로 소비자 GPU에서 LLM 파인튜닝하기
- LoRA 완전 정복: 저랭크 어댑테이션의 수학과 실전
- Full Fine-tuning vs PEFT: 전체 파라미터 vs 효율적 파인튜닝 완전 비교
- 파인튜닝 완전 정복: 사전 학습 모델을 내 데이터로 특화하는 방법
- 파인튜닝 vs 프롬프트 엔지니어링 vs RAG: 세 전략의 완전 비교
- RAG vs 파인튜닝: 언제 무엇을 선택해야 하나
- RAG 평가: RAGAS로 검색 품질과 답변 품질 측정하기
- Graph RAG: 지식 그래프로 RAG의 한계를 극복하다
- Agentic RAG: 에이전트가 스스로 검색하고 추론하는 시스템
- RAG 멀티홉 추론: 복잡한 질문을 단계적으로 해결하기
- RAG 쿼리 재작성: 검색 품질을 높이는 쿼리 변환 기법
- RAG 리랭킹: 검색 품질을 한 단계 끌어올리는 기술
- RAG 검색 전략 완전 정복: Sparse·Dense·Hybrid 검색 비교
- RAG 임베딩 모델 선택 가이드: 성능·비용·언어 지원 완전 비교
- RAG 청킹 전략 완전 정복: 문서를 어떻게 나눠야 하는가
- RAG 아키텍처 심화: Naive RAG에서 Modular RAG까지
- RAG 완전 정복: 검색 증강 생성의 핵심 원리
- pgvector 완전 정복: PostgreSQL로 벡터 검색 구현하기
- 벡터 데이터베이스 비교: Pinecone·Weaviate·Milvus·Qdrant·Chroma
- ANN 알고리즘 완전 정복: HNSW·IVF·LSH 비교 분석
- 벡터 유사도 지표: 코사인·유클리드·내적의 모든 것
- 벡터 검색 완전 정복: 의미 기반 검색의 동작 원리
- 프롬프트 평가: 좋은 프롬프트를 측정하는 방법
- 프롬프트 버전 관리: 프롬프트를 코드처럼 관리하기
- 컨텍스트 관리: 긴 대화에서 LLM이 기억을 유지하는 방법
- 프롬프트 인젝션 방어: LLM 보안의 첫 번째 전선
- 프롬프트 템플릿: 재사용 가능한 프롬프트 설계
- 시스템 메시지 설계: LLM의 역할과 경계를 정의하다
- Self-Consistency: 다수결로 정확도를 높이다
- ReAct: 추론과 행동을 결합한 에이전트 프롬프팅
- Tree-of-Thought: 여러 추론 경로를 탐색하다
- Chain-of-Thought 프롬프팅: LLM이 생각하게 만드는 기술
- Zero-shot과 Few-shot Learning: 예시의 힘
- 프롬프트 엔지니어링 완전 정복: AI와 대화하는 기술
- LLM 벤치마크 완전 해부: MMLU, HumanEval, LMSYS Chatbot Arena
- 한국 LLM 완전 해부: EXAONE, HyperCLOVA X, SOLAR
- Qwen과 DeepSeek: 중국 오픈소스 LLM의 도전
- Mistral 패밀리 완전 해부: 유럽 오픈소스 LLM의 반격
- LLaMA 패밀리 완전 해부: 오픈소스 LLM 혁명
- Gemini 패밀리 완전 해부: Google의 멀티모달 LLM 전략
- Claude 패밀리 완전 해부: Constitutional AI와 안전성 우선 설계
- GPT 패밀리 완전 해부: GPT-1부터 GPT-4o까지
- LLM의 한계와 환각: AI가 틀리는 이유
- 디코딩 방법: Greedy에서 Beam Search까지
- 샘플링 전략: LLM 출력 제어의 과학
- Temperature·Top-k·Top-p: 생성 다양성 제어
- 컨텍스트 윈도우: LLM의 작업 기억
- 창발적 능력: 규모에서 탄생하는 새로운 역량
- 스케일링 법칙: 더 크게, 더 많이, 더 강하게
- Constitutional AI: 원칙 기반 AI 정렬
- DPO: 보상 모델 없는 직접 선호도 최적화
- RLHF: 인간 피드백으로 LLM 정렬하기
- LLM 인스트럭션 튜닝: 지시를 따르는 모델 만들기
- LLM 사전학습: 수조 개 토큰으로 무엇을 배우나
- LLM의 본질: 거대 언어 모델이란 무엇인가
- 한국어 NLP: 교착어 처리와 한국어 특화 모델
- 지시 해소: 대명사가 가리키는 것을 찾아라
- 텍스트 생성: 언어 모델이 글을 쓰는 방법
- 기계 번역: 언어의 장벽을 넘는 기술
- 질의응답: 문서에서 답을 찾는 기술
- 텍스트 요약: 길고 복잡한 문서를 한 문단으로
- 텍스트 분류: 언어에 레이블을 붙이는 기술
- 감성 분석: 텍스트에서 감정과 의견을 읽다
- 품사 태깅(POS): 단어의 문법적 역할 파악
- 개체명 인식(NER): 텍스트에서 정보를 추출하다
- NLP 텍스트 전처리: 데이터를 모델에 맞게 다듬다
- 멀티모달 임베딩: 텍스트와 이미지를 같은 공간에
- 문장 임베딩: SBERT와 의미 검색
- 문맥적 임베딩: ELMo부터 BERT까지
- FastText: 부분 단어로 OOV를 정복하다
- GloVe: 전역 공기 통계로 단어 벡터를 만들다
- Word2Vec: 신경망으로 단어 의미를 학습하다
- 임베딩 기초: 단어를 벡터 공간에 배치하다
- tiktoken: OpenAI의 빠른 BPE 토크나이저
- SentencePiece: 언어에 구애받지 않는 토크나이저
- WordPiece: BERT의 서브워드 토크나이저
- BPE: 바이트 쌍 인코딩 토크나이저
- 토크나이저와 토큰: LLM이 텍스트를 보는 방법
- Mixture of Experts: 희소 활성화로 거대 모델 만들기
- MQA와 GQA: KV Cache 경량화 전략
- FlashAttention: IO-Aware 어텐션 연산
- RoPE: 회전으로 위치를 인코딩하다
- 효율적인 트랜스포머: 긴 시퀀스를 다루는 방법들
- BART: 시퀀스-투-시퀀스 사전학습 모델
- T5: 텍스트를 텍스트로 변환하는 통합 프레임워크
- GPT: 자기회귀적 언어 모델의 진화
- BERT: 양방향 사전학습 언어 모델의 등장
- Masking: 트랜스포머의 정보 차단 전략
- Encoder-Decoder 구조: 번역에서 요약까지
- Transformer Decoder: 문장을 생성하는 블록
- Transformer Encoder: 문맥을 이해하는 핵심 블록
- Positional Encoding: 트랜스포머에 순서를 알려주는 방법
- Multi-Head Attention: 여러 관점으로 동시에 보기
- Self-Attention: 모든 토큰이 모든 토큰과 대화한다
- Transformer 기초: Attention Is All You Need
- RNN의 한계와 Transformer로의 전환
- Attention 메커니즘: Seq2Seq 병목을 극복하다
- Seq2Seq: 인코더-디코더로 시퀀스를 시퀀스로
- 양방향 RNN: 과거와 미래를 동시에 보기
- GRU: 게이트 순환 유닛, LSTM의 경량 대안
- LSTM: 장단기 메모리 게이트 완전 해부
- RNN 기초: 순환 신경망의 작동 원리
- 인스턴스 분할: 물체를 개별로 구분하기
- 의미론적 분할: 픽셀 단위 이미지 이해
- 객체 탐지: 이미지에서 물체 찾기
- 이미지 분류: CNN 파이프라인 완전 가이드
- 현대 CNN: MobileNet, EfficientNet, ConvNeXt
- ResNet: 잔차 연결이 깊은 네트워크를 가능하게 한 이유
- CNN 아키텍처 역사: LeNet에서 EfficientNet까지
- 특징 맵: CNN이 이미지에서 보는 것
- 풀링: 공간 정보 압축과 불변성
- 합성곱 연산: CNN의 핵심 원리
- 기울기 소실과 폭발: 깊은 네트워크의 고질적 문제
- 드롭아웃: 과적합을 막는 앙상블 정규화
- 레이어 정규화: 트랜스포머가 선택한 정규화
- 배치 정규화: 내부 공변량 이동을 잡아라
- 가중치 초기화: Xavier, He, 그리고 수렴의 비밀
- MLP: 다층 퍼셉트론으로 임의의 함수를 근사하다
- 순전파와 역전파: 신경망 학습의 핵심 원리
- 활성화 함수: ReLU·Sigmoid·GELU의 모든 것
- 신경망 기초: 층, 파라미터, 순전파의 모든 것
- 퍼셉트론: 딥러닝의 기원이 된 인공 뉴런
- 클러스터링 평가 지표: 실루엣·DB·칼린스키-하라바시
- 랭킹 모델 평가: NDCG·MAP·MRR 이해하기
- 회귀 모델 평가 지표: MAE·MSE·RMSE·R² 완전 이해
- ROC 곡선과 AUC: 임계값 독립적 분류 성능 평가
- 혼동 행렬로 분류 오류 해부하기
- 분류 모델 평가 지표 완전 정복: 정확도·정밀도·재현율·F1
- 과대적합 완전 정복: 탐지·진단·해결 전략
- 편향-분산 트레이드오프: 과소적합과 과대적합의 근본 원인
- 교차 검증: K-Fold로 모델 성능을 더 정확히 추정하기
- 훈련·검증·테스트 세트 분리: 올바른 모델 평가의 기초
- t-SNE와 UMAP: 고차원 데이터를 눈으로 보다
- PCA: 고차원 데이터를 압축하는 차원 축소
- DBSCAN: 밀도로 찾는 군집과 이상치
- 계층적 군집화: 덴드로그램으로 보는 군집 구조
- K-평균 군집화: 데이터를 K개 그룹으로 나누는 법
- 그래디언트 부스팅: XGBoost·LightGBM의 기반 원리
- 랜덤 포레스트: 앙상블 학습의 교과서
- 결정 트리: 질문의 연쇄로 만드는 분류 모델
- 서포트 벡터 머신(SVM): 최대 마진 분류기의 원리
- 나이브 베이즈: 빠르고 강력한 확률적 분류기
- K-최근접 이웃(KNN): 가장 직관적인 분류 알고리즘
- 로지스틱 회귀: 분류 문제의 첫 걸음
- 선형 회귀: 예측 모델의 출발점
- 지도학습 vs 비지도학습: 머신러닝의 두 패러다임
- 정규화: 과적합을 막는 AI의 방패
- 손실 함수 완전 정복: 무엇을 최소화하는가
- 옵티마이저 완전 정복: SGD에서 AdamW까지
- 경사 하강법: AI 학습의 엔진
- 미적분학: AI 학습을 가능하게 하는 수학
- 정보 이론: AI가 불확실성을 측정하는 방법
- 베이즈 정리: AI 학습과 추론의 철학적 기반
- AI를 위한 확률론 기초: 불확실성을 다루는 수학
- 행렬 연산 완전 정복: AI에서 쓰이는 핵심 연산 5가지
- AI를 위한 선형대수 핵심: 스칼라·벡터·행렬·텐서
- 2025~2026 AI 생태계 전체 지도: 지금 무슨 일이 벌어지고 있나
- 데이터 중심 패러다임: 왜 데이터가 새로운 석유인가
- 기호주의 AI vs 통계적 AI: 두 패러다임의 70년 대결
- Narrow AI vs General AI vs Super AI — 세 가지 AI 유형 완전 정리
- AI 역사 — 1956년 다트머스에서 LLM 시대까지
- AI · ML · DL · LLM, 뭐가 다른가
SQL
맨 처음 ↓- 슬로우 쿼리 진단 — EXPLAIN으로 시작하는 성능 분석
- SQL 인젝션 방어 — 파라미터 바인딩과 안전한 쿼리 작성
- ENUM vs 룩업 테이블 — 코드성 데이터 설계
- 기본키 ID 전략 — AUTO_INCREMENT, UUID, ULID, Snowflake
- SELECT FOR UPDATE SKIP LOCKED — DB 큐 패턴
- 변경 이력 추적 — 히스토리 테이블 패턴
- 감사 컬럼 패턴 — created_at, updated_at, created_by
- Soft Delete vs Hard Delete — 논리 삭제의 트레이드오프
- 멱등성과 중복 처리 방지 패턴
- 커서 vs 오프셋 — 페이지네이션 전략
- Flyway · Liquibase · Alembic — DB 마이그레이션 도구
- N+1 문제 — 추적, 원인, 해결
- SQLAlchemy — Python ORM의 표준
- Sequelize · Prisma · TypeORM — Node.js ORM 3파전
- QueryDSL·jOOQ — 타입 안전 SQL 빌더
- MyBatis 동적 SQL — 유연한 쿼리 빌드
- JPA/Hibernate가 생성하는 SQL 이해하기
- Raw SQL vs ORM — 언제 무엇을 쓸까
- DuckDB — 임베디드 OLAP 엔진
- ClickHouse — 실시간 분석 특화 OLAP
- Redshift 아키텍처 — MPP 열 지향 DW
- Snowflake 아키텍처 — 스토리지·컴퓨팅 분리
- BigQuery 입문: 서버리스 열 지향 DW
- SCD (천천히 변하는 차원) 유형: Type 1·2·3
- 스타 스키마와 스노우플레이크 스키마
- OLAP vs OLTP — 두 워크로드의 근본적 차이
- Vitess — MySQL 위에 쌓는 수평 샤딩 미들웨어
- Amazon Aurora — 스토리지 분리로 구현하는 분산 내구성
- Google Spanner — TrueTime과 글로벌 일관성
- YugabyteDB — PostgreSQL과 Cassandra의 분산 결합
- TiDB — TiKV와 TiFlash로 구현하는 HTAP
- CockroachDB — 분산 SQL의 실전 구현
- 분산 트랜잭션의 한계와 실무 대응 전략
- 분산 트랜잭션의 두 축: 2PC와 SAGA 패턴
- 분산 SQL에서 CAP 이론의 위치 — NewSQL은 어디에 있는가
- CUBRID Java 연동 완전 가이드 — JDBC부터 Java 저장 프로시저까지
- CUBRID 아키텍처와 핵심 특징
- Altibase 하이브리드 구조 — 메모리와 디스크 데이터 티어링
- Altibase 인메모리 데이터베이스 아키텍처
- Tibero 관리 도구 — tbAdmin GUI와 tbcm CLI 완전 정리
- Oracle에서 Tibero로 마이그레이션 — 단계별 실전 가이드
- Tibero tbPSM — PL/SQL 호환 절차형 언어 완전 해설
- Tibero Active Cluster(TAC) 구조와 동작 원리
- Tibero RDBMS 아키텍처와 Oracle 호환성
- SQLite의 한계와 사용하면 안 되는 경우
- SQLite 모바일·임베디드 환경 활용
- SQLite FTS5 — 전문 검색 구현하기
- SQLite 동시성과 단일 writer 모델
- SQLite WAL 모드와 롤백 저널 — 트랜잭션 내구성 구현
- SQLite 타입 어파이니티 — 유연한 타입 시스템 이해하기
- SQLite 단일 파일 구조와 페이지 레이아웃
- SQLite — 라이브러리 형태와 임베디드 DB의 의미
- SQL Server SSRS — 보고서 서버와 구독 보고서 설계
- SQL Server SSAS — Analysis Services로 OLAP 큐브와 Tabular 모델 구축
- SQL Server SSIS — ETL 파이프라인 설계와 데이터 통합
- SQL Server 행 수준 보안 · Always Encrypted — 데이터 접근 제어
- SQL Server 파티셔닝 — Sliding Window 패턴
- SQL Server DMV 진단 — 성능 병목 실시간 분석
- SQL Server 복제 유형 — Snapshot · Transactional · Merge · P2P
- SQL Server Always On 가용성 그룹 — HA와 DR의 통합
- SQL Server 백업과 복원 — 전략과 실전 절차
- SQL Server 복구 모델 — Full · Bulk-Logged · Simple
- SQL Server 플랜 캐시와 Query Store — 실행 계획 재사용과 관리
- SQL Server 카디널리티 추정기 — 실행 계획 품질의 핵심
- SQL Server In-Memory OLTP — Hekaton 메모리 최적화 테이블
- SQL Server 컬럼스토어 인덱스 — OLAP 성능의 핵심
- SQL Server 필터된 인덱스 — 조건부 인덱스로 공간과 성능 최적화
- SQL Server 포함 열 인덱스 — INCLUDE 절 활용 가이드
- SQL Server 클러스터형 vs 비클러스터형 인덱스
- SQL Server 교착상태 분석 — 데드락 그래프 읽는 법
- NOLOCK 힌트의 위험성 — SQL Server 락 힌트 가이드
- SQL Server 격리 수준 — SNAPSHOT과 RCSI의 이해
- T-SQL 임시 테이블 vs 테이블 변수 — 언제 무엇을 쓸까
- T-SQL SEQUENCE와 IDENTITY — 자동 증가 키 완전 가이드
- T-SQL MERGE 문 — Upsert 완전 가이드
- T-SQL CTE와 APPLY 연산자 — 재사용 가능한 쿼리 작성법
- T-SQL 변수·제어흐름·TRY...CATCH — 절차형 프로그래밍 완전 가이드
- T-SQL 핵심 문법 — SQL Server 전용 확장 완전 가이드
- SQL Server 데이터 파일·로그 파일·파일 그룹 — 저장소 구조 완전 가이드
- SQL Server 버퍼 풀과 플랜 캐시 — 메모리 관리 완전 가이드
- SQL Server 스케줄러·워커·스레드 모델 — 협력적 스케줄링의 내부
- SQL Server SQLOS — 운영체제 추상화 계층 완전 가이드
- MariaDB System-Versioned Tables — 시간 여행 쿼리 완전 가이드
- MariaDB MaxScale — 지능형 데이터베이스 프록시 완전 가이드
- MariaDB Galera Cluster — 동기식 다중 Primary 클러스터 완전 가이드
- MariaDB Aria & ColumnStore — 스토리지 엔진 심층 분석
- MariaDB — MySQL에서 포크된 이유와 차별화 기능
- MySQL my.cnf 튜닝 — InnoDB·연결·리플리케이션 핵심 파라미터
- MySQL Performance Schema & sys 스키마 — 성능 진단 완전 가이드
- ProxySQL & MySQL Router — MySQL 연결 프록시 완전 가이드
- MySQL 백업 — mysqldump와 Percona XtraBackup 완전 가이드
- MySQL 파티셔닝 — 대용량 테이블 분할 전략과 파티션 프루닝
- MySQL 바이너리 로그 포맷 — STATEMENT·ROW·MIXED 완전 해설
- MySQL GTID 리플리케이션 — 자동 포지션 추적과 무중단 Failover
- MySQL 리플리케이션 — 비동기·반동기·그룹 리플리케이션
- MySQL JSON 타입과 가상 컬럼 — 반정형 데이터 처리
- MySQL 이벤트 스케줄러 — 자동 배치 작업 스케줄링
- MySQL 트리거 — 자동 감사와 무결성 보호
- MySQL 스토어드 프로시저와 함수 — 서버 사이드 로직 구현
- MySQL Derived Table Merge — 파생 테이블 병합 최적화
- MySQL 조인 알고리즘 — BNL · NLJ · Hash Join 완전 정리
- MySQL 통계 정보와 INFORMATION_SCHEMA — 옵티마이저의 눈
- MySQL 옵티마이저 힌트 — 실행 계획 직접 제어하기
- MySQL EXPLAIN 완전 해석 — TRADITIONAL · JSON · TREE · ANALYZE
- MySQL FULLTEXT 인덱스 — 전문 검색 구현과 한계
- MySQL Functional Index — 표현식 기반 인덱스로 함수 쿼리 최적화
- MySQL Invisible Index — 안전한 인덱스 비활성화와 삭제 전략
- MySQL Index Condition Pushdown — 스토리지 엔진 레벨 필터링
- MySQL Leftmost Prefix 규칙 — 복합 인덱스 칼럼 순서 설계
- MySQL B+ Tree 인덱스 내부 구조 — 페이지, 높이, 분할
- MySQL 클러스터드 인덱스와 세컨더리 인덱스 — InnoDB 인덱스 구조의 핵심
- MySQL autocommit과 트랜잭션 제어 — START TRANSACTION, SAVEPOINT
- MySQL 데드락 분석 — SHOW ENGINE INNODB STATUS 읽는 법
- MySQL Gap Lock · Next-Key Lock — 팬텀 읽기 방지 메커니즘
- MySQL REPEATABLE READ — 기본 격리 수준과 Gap Lock
- MySQL InnoDB MVCC — 버전 체인과 ReadView
- InnoDB Change Buffer — Secondary Index 쓰기 최적화
- InnoDB Adaptive Hash Index — 자동으로 만들어지는 해시 인덱스
- InnoDB Doublewrite Buffer — 부분 쓰기(Partial Page Write) 방지
- InnoDB Redo Log와 Undo Log — 복구와 MVCC의 두 기둥
- InnoDB Buffer Pool과 LRU — Midpoint Insertion 전략
- InnoDB 디스크 레이아웃 — 테이블스페이스, 세그먼트, 익스텐트, 페이지
- MySQL 쿼리 캐시가 사라진 이유 — 글로벌 Mutex의 함정
- MySQL 커넥션과 스레드 모델 — Thread-per-Connection 구조
- MySQL 스토리지 엔진 — InnoDB·MyISAM·Memory
- MySQL 아키텍처 개요 — 서버 레이어와 스토리지 엔진
- PostgreSQL 슬로우 쿼리 진단 — pg_stat_statements와 EXPLAIN
- postgresql.conf 핵심 파라미터 튜닝 가이드
- PgBouncer — PostgreSQL 커넥션 풀링
- pgBackRest와 Barman — PostgreSQL 백업 솔루션
- PostgreSQL PITR과 베이스 백업 — 복구 시점 제어
- PostgreSQL 논리 복제 — 선택적 복제와 버전 업그레이드
- PostgreSQL 스트리밍 복제 — WAL 기반 고가용성
- PostgreSQL 구체화 뷰 — REFRESH 전략과 쿼리 최적화
- PostgreSQL 선언적 파티셔닝 — RANGE·LIST·HASH
- PostgreSQL FDW — Foreign Data Wrapper로 외부 데이터 연결
- PostgreSQL 전문 검색 — tsvector와 tsquery
- PostGIS 입문 — 지리 데이터 타입과 공간 쿼리
- pg_stat_statements — 쿼리 통계로 슬로우 쿼리 잡기
- PostgreSQL 확장 시스템 — CREATE EXTENSION과 주요 확장들
- PostgreSQL 함수 파라미터와 다형성 — ANYELEMENT, 오버로딩
- PostgreSQL 언어 옵션 — SQL, PL/pgSQL, PL/Python, C까지
- PostgreSQL 프로시저 — CALL과 트랜잭션 제어
- PostgreSQL 트리거 함수 — BEFORE·AFTER·INSTEAD OF 완전 가이드
- PL/pgSQL 제어 흐름 — IF, LOOP, EXCEPTION 완전 가이드
- PostgreSQL 함수 작성 — SQL과 PL/pgSQL 기초
- 확장 통계 — 다중 컬럼 상관관계를 옵티마이저에게 알리는 방법
- 플래너 옵션 — 옵티마이저 동작을 제어하는 GUC 파라미터
- 조인 순서와 GEQO — 옵티마이저가 최적 조인 순서를 찾는 방법
- ANALYZE와 통계 — 옵티마이저가 신뢰하는 데이터
- EXPLAIN ANALYZE 읽기 — 실행 계획 해석 완전 가이드
- Index-Only Scan 완전 이해 — 언제 힙을 건너뛰는가
- 표현식 인덱스 — 함수와 연산 결과에 인덱스 걸기
- Covering Index와 INCLUDE — 힙 접근 없는 인덱스 스캔
- SP-GiST와 BRIN 인덱스 — 특수 목적 인덱스 구조
- VACUUM과 Dead 튜플 — 더티 공간 회수의 원리
- GiST 인덱스 — 범위, 기하, 전문화된 검색 구조
- MVCC — xmin, xmax, ctid로 이해하는 다중 버전 동시성
- GIN 인덱스 — 전문 검색과 배열, JSONB 역인덱스
- 테이블 상속 — INHERITS와 파티셔닝의 뿌리
- IDENTITY vs SEQUENCE — 자동 증가 키 생성 전략
- PostgreSQL Hash 인덱스 — 등호 조회 전용 구조
- PostgreSQL B-Tree 인덱스 내부 구조
- 사용자 정의 타입과 도메인 — CREATE TYPE, CREATE DOMAIN
- PostgreSQL 범위 타입 — daterange, tstzrange와 겹침 방지
- SELECT FOR UPDATE와 SKIP LOCKED — 행 수준 잠금 패턴
- JSONB GIN 인덱스 — 문서 검색 최적화
- PostgreSQL 락 유형과 pg_locks — 잠금 계층 이해
- JSON vs JSONB — 저장 구조와 선택 기준
- SSI — 직렬화 스냅샷 격리의 충돌 감지
- PostgreSQL 격리 수준 구현 — 스냅샷과 가시성 체크
- PostgreSQL 배열 타입과 UNNEST — 다차원 데이터 처리
- PostgreSQL Autovacuum 튜닝 — 자동 공간 회수의 최적화
- PostgreSQL 풍부한 데이터 타입 — 표준을 넘어서
- Checkpointer와 BGWriter — 더티 페이지 플러시
- PostgreSQL WAL 메커니즘
- PostgreSQL 스토리지 — Heap과 TOAST
- Shared Buffers와 work_mem — PostgreSQL 메모리 심화
- PostgreSQL 프로세스 모델
- PostgreSQL 아키텍처 개요
- 멀티테넌트 — CDB와 PDB
- NLS와 한국어 환경 설정
- 통계 정보와 SQL 튜닝 어드바이저
- AWR과 ASH — Oracle 성능 진단의 양대 축
- RMAN 백업과 복구
- Oracle Data Guard
- Oracle RAC 개요
- Advanced Queuing (AQ)
- Database Link
- Materialized View와 Query Rewrite
- 파티션-와이즈 조인
- Oracle Interval 파티셔닝
- Oracle 파티셔닝: Range·List·Hash
- BULK COLLECT와 FORALL
- PL/SQL 컬렉션
- PL/SQL 트리거, 시퀀스, 시노님
- PL/SQL 패키지
- PL/SQL 변수, 커서, 예외
- PL/SQL 블록 구조
- Oracle SQL Plan Management (SPM)
- Oracle 옵티마이저 힌트
- Oracle RBO vs. CBO
- Oracle Index-Organized Table (IOT)
- Oracle Function-Based Index (FBI)
- Oracle Reverse Key 인덱스
- Oracle 비트맵 인덱스
- Oracle B-Tree 인덱스
- Oracle Enqueue·래치·뮤텍스
- Oracle 잠금 메커니즘
- Oracle 격리 수준: Read Committed와 Serializable
- Oracle MVCC 구현
- Oracle SCN과 읽기 일관성
- Oracle Redo·Undo·플래시백
- Oracle 스토리지 구조: 테이블스페이스·세그먼트·익스텐트·블록
- Oracle 백그라운드 프로세스
- Oracle 메모리 구조 — SGA·PGA·UGA
- Oracle 인스턴스와 데이터베이스
- 통계와 선택도
- 정렬과 집계의 비용
- 조인 알고리즘
- 비용 기반 옵티마이저(CBO)
- 인덱스가 사용되지 않는 패턴
- 해시 인덱스
- 부분 인덱스와 함수 기반 인덱스
- 커버링 인덱스
- 복합 인덱스 컬럼 순서
- B-Tree 인덱스 구조
- 풀스캔 비용 이해
- 다형성 관계(Polymorphic Relationship)
- 수퍼타입/서브타입 테이블 설계
- 식별 관계 vs 비식별 관계
- 관계 매핑: ERD를 테이블로 변환하기
- ER 다이어그램 읽기와 그리기
- 비정규화: 언제, 어떻게 결정하는가
- 정규화: 1NF ~ BCNF
- SAVEPOINT와 부분 롤백
- 데드락의 본질과 해결
- 2PL과 MVCC 이론
- 동시성 이상 현상
- 트랜잭션 격리 수준 표준
- ACID 속성 완전 이해
- PIVOT · UNPIVOT 패턴
- UNION · INTERSECT · EXCEPT 집합 연산
- 타임존 처리와 AT TIME ZONE
- 날짜·시간 함수와 INTERVAL 연산
- LIKE, SIMILAR TO, 정규식 패턴 매칭
- 표준 문자열 함수
- COALESCE와 NULLIF — NULL 처리 도구
- CASE 표현식 — Simple과 Searched CASE
- 윈도우 프레임 — ROWS BETWEEN과 RANGE BETWEEN
- PARTITION BY와 ORDER BY의 역할
- 이동 평균과 누적 합계
- LAG / LEAD — 이전·다음 행 참조
- ROW_NUMBER, RANK, DENSE_RANK — 순위 함수와 동점 처리
- 윈도우 함수 입문 — OVER 절과 파티션
- 재귀 CTE — 계층 구조와 그래프 순회
- CTE — WITH 절로 쿼리를 구조화하기
- ANY · ALL · SOME — 집합 비교 연산자
- EXISTS와 NOT EXISTS — 반존재 조건 처리
- 상관 서브쿼리 — 외부 쿼리를 참조하는 서브쿼리
- 인라인 뷰 — FROM 절 서브쿼리 활용
- 스칼라 서브쿼리 — 단일 값 반환과 성능
- DISTINCT 집계 — COUNT DISTINCT의 비용과 대안
- 조건부 집계 — CASE WHEN + 집계함수, FILTER 절
- GROUPING SETS · ROLLUP · CUBE
- HAVING vs WHERE — 필터 위치가 중요한 이유
- 집계 함수 완전 정리
- GROUP BY의 본질
- JOIN 순서와 성능
- 다중 JOIN 쿼리 가독성
- NATURAL JOIN과 USING 절
- 셀프 조인과 계층형 데이터
- CROSS JOIN과 카테시안 곱
- OUTER JOIN — LEFT, RIGHT, FULL 완전 정리
- INNER JOIN — 가장 기본적인 조인
- 별칭(Alias)과 쿼리 가독성
- DISTINCT의 비용과 대안
- LIMIT / OFFSET / FETCH FIRST — 페이지 처리
- ORDER BY와 NULL 정렬
- IN · BETWEEN · IS NULL
- LIKE 패턴 매칭
- WHERE 절과 비교 연산자
- SELECT의 논리적 실행 순서
- RETURNING / OUTPUT — DML 결과를 즉시 돌려받기
- MERGE / UPSERT — 있으면 수정, 없으면 삽입
- 안전한 삭제 — DELETE 문 사용법
- 데이터 수정 — UPDATE와 UPDATE JOIN
- 데이터 삽입 — INSERT 문의 기본과 응용
- DROP vs TRUNCATE — 삭제의 두 얼굴
- 테이블 변경 — ALTER TABLE로 스키마 진화시키기
- 유니크 제약 — UNIQUE 인덱스와 NULL 허용 동작
- 외래 키와 참조 무결성 — FOREIGN KEY의 작동 원리
- 기본 키 설계 — PRIMARY KEY의 본질과 전략
- 컬럼 제약 조건 — NOT NULL · DEFAULT · CHECK
- 데이터 타입 표준 (날짜·시간) — DATE·TIME·TIMESTAMP와 타임존 함정
- 데이터 타입 표준 (숫자·문자열·불리언) — 언제 어떤 타입을 써야 하는가
- CREATE TABLE 기초 — 테이블을 제대로 정의하는 방법
- SQL 언어 분류 — DDL · DML · DCL · TCL
- 클라이언트-서버 모델과 와이어 프로토콜
- SQL의 역사와 표준 — ANSI/ISO/JIS
- 관계형 모델 이론 — 관계·튜플·속성
- 데이터베이스란 무엇인가 — 파일 시스템과의 차이
JavaScript
맨 처음 ↓- 다크 모드 — CSS 변수와 prefers-color-scheme 구현
- 웹 접근성(a11y) — ARIA와 키보드 내비게이션 구현
- 국제화(i18n) — react-i18next로 다국어 지원 구현
- 폼 유효성 검사 — RHF + Zod로 견고한 폼 만들기
- 제어 컴포넌트와 비제어 컴포넌트 — 폼 상태 관리 전략
- 페이지네이션 클라이언트 — 커서·오프셋·무한 스크롤 구현
- 토큰 저장 전략 — 브라우저에서 인증 토큰 안전하게 관리하기
- 구조화 로그 실전 — JSON 로그와 상관 ID
- 로깅 실전 — 레벨 전략과 구조화 로그
- 설정 우선순위 — 환경별 설정 오버라이드 전략
- 환경 변수 실전 — Node.js와 브라우저에서 설정 관리하기
- 미디에이터·믹스인 패턴 — 협력과 조합
- 모듈 패턴 — 캡슐화와 네임스페이스
- 어댑터·퍼사드·프록시 패턴 — 구조 패턴의 세 가지 얼굴
- 전략·데코레이터 패턴 — 행위의 교체와 확장
- 싱글턴·팩토리 패턴 — 객체 생성의 제어와 추상화
- 옵저버·발행-구독 패턴 — 느슨한 결합의 이벤트 설계
- 에러를 값으로 — 함수형 에러 설계 패턴
- Option/Result 타입 — 함수형 에러 처리
- Immer와 Immutable.js — 불변 데이터 구조 라이브러리
- Ramda와 lodash/fp — 함수형 유틸리티 라이브러리
- 펑터와 모나드 입문 — 함수형 프로그래밍의 핵심 추상
- 순수 함수와 불변성 — 함수형 프로그래밍의 기초
- 의존성 감사 — npm audit과 공급망 보안
- 프로토타입 오염 — Prototype Pollution 공격과 방어
- eval과 new Function의 보안 위험
- OAuth 2.0 클라이언트 흐름 — PKCE와 Authorization Code
- JWT 저장 전략 — localStorage vs HttpOnly 쿠키
- 쿠키 보안 — HttpOnly·Secure·SameSite·__Host 접두사
- SRI — 서브리소스 무결성 검증
- CORS 심층 분석 — 프리플라이트와 자격증명 요청
- Content-Security-Policy — 인라인 스크립트 차단과 nonce 전략
- CSRF와 SameSite 쿠키 — 사이트 간 요청 위조 방어
- XSS(크로스 사이트 스크립팅) 완전 정복
- CPU 프로파일링과 플레임 차트 — 병목 함수 찾기
- 메모리 프로파일링 — 누수 탐지와 힙 스냅샷
- Lighthouse와 WebPageTest — 성능 측정 도구 완전 정복
- Core Web Vitals — LCP·INP·CLS 완전 가이드
- 크리티컬 CSS와 폰트 — 렌더 블로킹 제거
- 이미지 지연 로딩 — Intersection Observer와 loading 속성
- requestIdleCallback — 유휴 시간 활용
- 메모이제이션 패턴 — 계산 결과 캐싱으로 성능 향상
- 디바운스와 스로틀 — 이벤트 호출 빈도 제어
- JS 파싱·컴파일 비용 — 번들 크기가 성능에 미치는 영향
- SWR — stale-while-revalidate 서버 상태 관리
- TanStack Query — 서버 상태 관리의 표준
- RxJS 입문 — Observable과 반응형 프로그래밍
- MobX — 반응형 상태 관리
- Zustand · Jotai · Recoil — 가벼운 상태 관리 비교
- Redux Toolkit — 현대적 Redux 개발
- Redux 핵심 — 단방향 데이터 흐름과 미들웨어
- 메타 프레임워크 완전 가이드 — Next.js, Nuxt, SvelteKit, Remix, Astro
- Next.js App Router 완전 가이드
- 렌더링 전략 완전 정복 — CSR·SSR·SSG·ISR·Streaming
- Qwik 핵심 — 재개 가능성(Resumability)과 O(1) 로딩
- SolidJS 핵심 — 세밀한 반응성과 Virtual DOM 없는 선언적 UI
- Angular 핵심 — Zone.js, DI, 변경 감지, Signals
- Svelte 핵심 — 컴파일러 기반 반응성과 Virtual DOM 없는 렌더링
- Vue 3 핵심 — Composition API, Reactivity, Virtual DOM
- React 핵심 원리 — Virtual DOM, Fiber, Reconciliation
- SPA vs MPA vs MFE — 프론트엔드 아키텍처 선택
- ESLint 커스텀 규칙 — AST 기반 규칙 작성
- Husky + lint-staged — 커밋 훅으로 품질 게이트 구축
- TypeScript ESLint — 타입 인식 린팅 완전 가이드
- Prettier와 ESLint 역할 분리 — 포맷터와 린터 공존
- ESLint 기초 — 파서·규칙·플러그인·Flat Config
- 커버리지와 테스트 신뢰성 — 숫자 너머의 품질
- 스냅샷 테스트의 함정 — 올바른 활용 패턴
- Mock 전략 — Fake·Stub·Spy·Mock 완전 정리
- 테스트 피라미드 — 전략적 테스트 포트폴리오 구성
- Playwright vs Cypress — E2E 테스트 프레임워크 완전 비교
- Testing Library — 사용자 관점 UI 컴포넌트 테스트
- Mocha + Chai — 유연한 클래식 테스트 스택
- Vitest — Vite 네이티브 테스트 러너 완전 정복
- Jest — JavaScript 테스트 프레임워크 완전 정복
- 코드 스플리팅 심층 분석 — 최적 청킹 전략
- Tree Shaking 심층 분석 — 죽은 코드 완전 제거
- 소스맵 완전 정복 — 디버깅의 숨은 열쇠
- Parcel · Turbopack — 무설정·Rust 차세대 번들러
- Vite — 차세대 프론트엔드 빌드 도구
- Rollup — 라이브러리 번들러의 표준
- webpack — 모듈 번들러의 완전 정복
- SWC · esbuild — Rust·Go 기반 초고속 변환기
- Babel 완전 해부 — 트랜스파일러의 동작 원리
- Cloudflare Workers와 workerd 런타임
- Bun · JSC 기반 런타임과 내장 번들러
- Deno 보안 모델과 표준 라이브러리
- node_modules 호이스팅과 의존성 해석
- 모노레포 · 워크스페이스 패턴
- SemVer · Node.js 버전 관리 전략
- package.json 핵심 필드 완전 정복
- npm · yarn · pnpm 패키지 매니저 비교
- 디버깅 · Node.js inspect와 진단 도구
- process · Node.js 프로세스 환경
- child_process · Node.js 자식 프로세스
- Cluster · Node.js 멀티프로세스
- Worker Threads · Node.js 멀티스레드
- EventEmitter · Node.js 이벤트 패턴
- http · https · http2 · Node.js 네트워크 서버
- Buffer & Stream · 바이너리 데이터와 스트리밍
- fs · path · os · 파일 시스템과 환경 API
- Node.js ESM · ES 모듈 완전 가이드
- CommonJS & require() · Node.js 모듈 시스템
- Node.js 아키텍처 · V8·libuv·이벤트 루프
- WebAssembly + Worker · 고성능 연산 통합
- Structured Clone & Transferable · Worker 데이터 전송
- SharedArrayBuffer & Atomics · 워커 메모리 공유
- Dedicated Worker vs Shared Worker · 스레드 공유 패턴
- Web Worker 기초 · 멀티스레드 JavaScript
- Web Share API · 네이티브 공유 다이얼로그
- Background Sync API · 오프라인 요청 큐
- Push API · 브라우저 푸시 알림
- Service Worker 기초 · 오프라인 캐싱
- WebRTC 개요 · P2P 실시간 통신
- WebSocket API 완전 이해
- Server-Sent Events · EventSource 완전 이해
- Streams API · ReadableStream 완전 이해
- Fetch 취소 · AbortController 완전 이해
- Fetch API 완전 이해
- requestAnimationFrame · requestIdleCallback 완전 이해
- Performance API 완전 이해
- Web Cryptography API 완전 이해
- Permissions API 완전 이해
- Notifications API 완전 이해
- Geolocation API 완전 이해
- Cache API 완전 이해
- IndexedDB 완전 이해
- Cookie API 완전 이해
- localStorage · sessionStorage 완전 이해
- location · history API 완전 이해
- window · document · navigator 완전 이해
- 클립보드 API 완전 이해
- 드래그 앤 드롭 완전 이해
- 키보드·마우스·터치·포인터 이벤트 완전 이해
- 커스텀 이벤트 완전 이해
- addEventListener 옵션 완전 이해
- preventDefault · stopPropagation 완전 이해
- event.target · currentTarget · relatedTarget 완전 이해
- 이벤트 캡처·버블 — 전파 단계 완전 이해
- 이벤트 위임 — 효율적인 이벤트 리스너 관리
- template · slot — 웹 컴포넌트 마크업 청사진
- Shadow DOM · Custom Elements — 웹 컴포넌트 기초
- ResizeObserver · IntersectionObserver — 요소 크기와 가시성 감지
- MutationObserver — DOM 변화 감지
- style · CSSOM — 자바스크립트로 스타일 다루기
- innerHTML · textContent · innerText 완벽 비교
- DocumentFragment — 배치 삽입으로 리플로우 줄이기
- classList · attributes · dataset — 요소 속성 조작 API
- DOM 요소 생성·삽입·제거 — createElement부터 replaceWith까지
- DOM 요소 선택 — querySelector와 선택 API 완전 정복
- Document · Element · Node · Text — DOM의 핵심 인터페이스
- DOM 트리 구조 — 문서를 객체로 표현하는 방법
- Blob · File · FileReader — 파일과 이진 데이터 다루기
- TextEncoder · TextDecoder — 텍스트와 이진 데이터 변환
- URL · URLSearchParams — 브라우저 URL 파싱 API
- Intl 기타 API — Segmenter, PluralRules, DisplayNames
- Intl.Collator — 로케일 인식 문자열 정렬
- Intl.NumberFormat · DateTimeFormat — 국제화 포맷팅
- JSON — 직렬화 옵션과 활용
- 정규식 심화 — 그룹·후방탐색·플래그
- Date와 타임존 — 날짜 다루기의 모든 것
- Number와 Math — 수치 연산 완전 정복
- Object 정적 메서드 총정리
- 문자열 메서드와 정규식 활용
- 배열 메서드 — 변경 vs 비변경 완전 정복
- 배열 메서드 총람 — 순회·변환·검색·집계
- NaN과 특수 숫자값 비교 — 자기 자신과 같지 않은 값
- Truthy · Falsy — 조건식에서의 값 판별
- Symbol.toPrimitive — 객체의 원시값 변환 제어
- 암묵적 형변환 — 자동 타입 변환의 규칙
- 명시적 형변환 — Number, String, Boolean
- typeof · instanceof의 한계와 올바른 타입 판별
- 클로저와 메모리 — 스코프가 메모리를 어떻게 붙잡는가
- WeakRef 활용 — 캐시와 파이널라이저 패턴
- 메모리 누수 패턴 — 원인 분석과 탐지
- 가비지 컬렉션 — Mark & Sweep과 세대별 GC
- 메모리 모델 — 힙·스택·참조의 구조
- 미처리 Rejection — 전역 에러 경계 설계
- 비동기 에러 패턴 — 실전 설계 전략
- AggregateError — 여러 에러를 하나로
- Error cause (ES2022) — 에러 원인 연결
- 커스텀 Error 클래스 — 도메인 에러 설계
- Error 객체와 스택 트레이스 — 구조와 활용
- throw와 try/catch/finally — 에러 전파의 기초
- 비동기 큐와 세마포어 — 흐름 제어 패턴
- AbortController — 비동기 작업 취소
- 동시성 제한 — Promise Pool과 p-limit
- async/await 에러 처리 패턴 — try/catch·에러 래핑·fallback
- async/await 내부 동작 — 제너레이터와 Promise의 결합
- Promise 조합 — all·allSettled·race·any
- Promise 체이닝과 에러 처리 — .then·.catch·.finally
- Promise 상태 — pending·fulfilled·rejected의 전이
- 타이머 완전 비교 — setTimeout·setInterval·queueMicrotask·rAF
- 이벤트 루프 완전 해부 — 태스크·마이크로태스크·렌더링
- JavaScript 동시성 모델 — 싱글 스레드가 멈추지 않는 이유
- 모듈 캐시와 순환 의존성 — 한 번 로드, 영원한 공유
- Import Maps — 빌드 없이 브라우저에서 bare specifier 사용하기
- 트리 쉐이킹 — 사용하지 않는 코드를 제거하는 기술
- UMD·AMD·IIFE — 모듈 시스템의 역사
- CommonJS vs ES 모듈 — 두 시스템의 결정적 차이
- Top-Level Await — 모듈 최상위의 비동기 처리
- 동적 import() — 지연 로딩과 코드 분할
- import/export 문법 총정리
- ES 모듈 기초 — import/export 핵심 이해
- Promise.withResolvers() — 외부에서 제어하는 Promise
- 배열 불변 메서드 — 원본을 건드리지 않는 방법들
- 실행 컨텍스트 — JavaScript 코드가 동작하는 환경
- Object.groupBy() — 배열 그룹화
- structuredClone()
- Error cause (ES2022)
- findLast와 findLastIndex
- Object.hasOwn()
- 배열과 문자열의 .at() 메서드
- WeakRef와 FinalizationRegistry
- 최상위 await (Top-level await)
- 숫자 구분자 (Numeric Separator)
- 논리 할당 연산자 (&&=, ||=, ??=)
- Proxy와 Reflect
- Symbol 활용 패턴
- WeakMap과 WeakSet
- Map과 Set
- 비동기 이터러블과 for await...of
- Symbol.iterator 심화
- 제너레이터 응용 패턴
- 이터레이터 프로토콜
- 이터러블 프로토콜
- JavaScript 반복문 완전 정리
- 데코레이터 — @syntax로 클래스와 메서드 꾸미기
- 믹스인 패턴 — 다중 상속 없이 기능 합성하기
- instanceof와 Symbol.hasInstance — 타입 검사의 비밀
- extends와 super — JavaScript 상속의 실제 동작
- 클래스 getter/setter — 계산된 프로퍼티 설계
- 프라이빗 필드 — # 접두사로 구현하는 캡슐화
- 정적 멤버 — 클래스 레벨 프로퍼티와 메서드
- 생성자와 인스턴스 — new 연산자의 동작 원리
- 클래스 문법 입문 — ES6 class 키워드 완전 이해
- 객체 순회 완전 정복 — for...in부터 Reflect.ownKeys까지
- 객체 복사 완전 가이드 — 얕은 복사부터 structuredClone까지
- 프로토타입 메서드 총정리 — 객체 탐색과 복제 도구
- 프로토타입 상속 심화 — extends와 super의 내부 동작
- Object.create — 프로토타입을 직접 지정해서 객체 만들기
- __proto__ vs prototype — 두 이름의 혼동 완전 정리
- 프로토타입 체인 — 상속의 실제 동작 원리
- freeze · seal · preventExtensions — 객체 불변성 3단계
- Object.defineProperty 완전 해부 — 프로퍼티를 코드로 조각하기
- getter와 setter — 프로퍼티 접근을 함수로 위장하기
- 프로퍼티 디스크립터 — 객체 속성을 정밀하게 제어하는 메타데이터
- 객체 생성 패턴 — 팩토리, 생성자, 클래스, Object.create
- 이벤트 핸들러와 this — currentTarget과 바인딩
- 클래스 메서드와 this — 잃어버리기 쉬운 컨텍스트
- call, apply, bind 완전 이해
- 화살표 함수와 this — 선언 시점의 this를 캡처한다
- this 규칙 완전 정복 — 호출 방식이 this를 결정한다
- 클로저와 메모리 누수 — 언제 문제가 되는가
- 클로저 패턴 — 실전 활용법
- 클로저의 본질 — 함수가 기억하는 것
- 콜 스택 — JavaScript 실행 흐름의 핵심
- 함수 스코프 vs 블록 스코프
- 렉시컬 스코프
- 스코프 체인
- 비동기 제너레이터
- 제너레이터 함수
- 꼬리 호출 최적화의 한계
- 함수 합성
- 메모이제이션
- 커링과 부분 적용
- 순수 함수와 부수 효과
- 고차 함수 완전 정복
- IIFE — 즉시 실행 함수 표현식 완전 정복
- arguments 객체 완전 정복
- 기본값 파라미터와 나머지 파라미터
- 일급 함수 완전 정복
- 화살표 함수와 this
- 함수 선언식 vs 함수 표현식
- 템플릿 리터럴 완전 정복
- 구조 분해 할당 완전 정복
- 스프레드와 나머지 파라미터 완전 정복
- 비트 연산자 완전 정복
- 옵셔널 체이닝 ?.
- 단락 평가, Nullish 병합, 논리 대입 연산자
- 산술·비교·논리 연산자 완전 정복
- 동등 비교 완전 정리 — ==, ===, Object.is
- 참조와 메모리 — 값 복사 vs 참조 복사
- null과 undefined의 차이
- Symbol과 Well-Known Symbol
- string과 유니코드 완전 해부
- BigInt — 안전한 정수 범위를 넘어서
- number의 IEEE 754 정밀도와 함정
- 원시 타입 7가지 — JavaScript의 기본 데이터
- TDZ (Temporal Dead Zone) — 시간적 사각지대
- 호이스팅의 본질 — 선언이 끌어올려지는 원리
- var · let · const 차이 — 스코프, 호이스팅, 재할당
- Strict mode와 Sloppy mode — 더 안전한 JavaScript
- 런타임 환경 — 브라우저 · Node · Deno · Bun
- JS 엔진 — V8 · SpiderMonkey · JavaScriptCore
- ECMAScript 표준과 버전 이름 — ES5·ES6·ES2015~ES2024
- JavaScript란 무엇인가 — 브라우저 스크립팅에서 범용 언어로
Java
맨 처음 ↓- 정적 분석 도구 활용 NEW
- 자바 코딩 컨벤션 NEW
- 레거시 코드 현대화 전략 NEW
- 제거·폐기된 API 정리 NEW
- Java 17 → 21 마이그레이션 NEW
- Java 11 → 17 마이그레이션 NEW
- Java 8 → 11 마이그레이션 NEW
- 역직렬화 취약점 — 안전하지 않은 역직렬화 방어 NEW
- 입력 검증 — 신뢰할 수 없는 데이터 다루기 NEW
- JWT — jjwt로 토큰 기반 인증 구현하기 NEW
- TLS와 KeyStore — Java 전송 구간 보안 NEW
- JCA — Java 암호화 아키텍처 NEW
- Java 보안 개요 — 심층 방어와 보안 3대 목표 NEW
- Java와 Kotlin 상호운용
- Java vs Scala — 함수형의 무게
- Java vs Kotlin — 무엇이 다른가
- JVM 언어 생태계 개관
- gRPC — 고성능 RPC 프레임워크
- WebSocket — 양방향 실시간 통신
- Java 11 HttpClient — 현대적인 HTTP 클라이언트
- HttpURLConnection — 표준 라이브러리로 HTTP 호출하기
- ServerSocket — 자바로 서버를 여는 법
- 소켓 기초 — TCP 통신의 출발점
- MyBatis — SQL을 분리해 관리하는 SQL 매퍼
- jOOQ — 타입 안전한 SQL을 자바로 작성하기
- Hibernate — JPA를 구현한 가장 널리 쓰이는 ORM 엔진
- JPA 개요 — 객체와 관계형 데이터베이스의 다리
- 커넥션 풀 — 연결을 재사용해 비용을 줄이기
- JDBC 배치 — 여러 SQL을 한 번에 모아 보내기
- JDBC 트랜잭션 — 여러 SQL을 하나의 단위로 묶기
- PreparedStatement — SQL 인젝션을 막는 매개변수 바인딩
- JDBC 기초 — 자바와 데이터베이스를 잇는 표준
- MDC로 로그 추적하기 — 요청을 처음부터 끝까지 잇는 컨텍스트
- java.util.logging (JUL) — JDK 내장 로깅
- Log4Shell — Log4j 2 원격 코드 실행 취약점
- Log4j 2 — 비동기 로깅과 고성능
- Logback — SLF4J의 기본 구현체
- SLF4J — 로깅 파사드의 표준
- 자바 로깅 개요 — 파편화된 생태계 이해하기
- 뮤테이션 테스트 — PIT로 테스트의 품질을 검증하기
- 테스트 커버리지 — JaCoCo로 측정하고 해석하기
- ArchUnit — 아키텍처를 테스트로 강제하기
- Testcontainers — 진짜 의존성으로 통합 테스트하기
- AssertJ — 유창한 단언의 기술
- Mockito 스터빙과 검증 심화
- Mockito 입문 — 테스트 더블의 세계
- JUnit 5 파라미터화 테스트 — 하나의 테스트, 여러 입력
- JUnit 5 생명주기 — 테스트의 준비와 정리
- JUnit 5 입문 — 현대 자바 테스트의 표준
- BOM — 의존성 버전 한 곳에서 관리하기
- 멀티 모듈 빌드 — 프로젝트를 모듈로 나누기
- Gradle vs Maven — 무엇을 선택할까
- Gradle Task — 빌드의 최소 실행 단위
- Gradle 입문 — 유연한 빌드 자동화
- Maven 플러그인 — 빌드를 확장하는 법
- Maven 라이프사이클 — 빌드 단계 완전 이해
- Maven 입문 — 자바 빌드 도구의 표준
- GraalVM 트레이드오프 — 언제 쓰고 언제 피할까
- GraalVM 폴리글랏 — 하나의 런타임, 여러 언어
- GraalVM AOT 컴파일 — 미리 컴파일하는 자바
- GraalVM Native Image — 네이티브 실행 파일 만들기
- GraalVM 개요 — 고성능 폴리글랏 런타임
- 자바 기동 시간 최적화 — 빠르게 시작하는 JVM
- async-profiler — 낮은 오버헤드의 프로파일링
- 클래스 데이터 공유(CDS) — JVM 기동을 빠르게
- JVM 플래그 — 표준·-X·-XX 옵션 이해하기
- JMH — 신뢰할 수 있는 마이크로벤치마크
- 루프 언롤링 — JIT가 반복문을 펼치는 이유
- 문자열 중복 제거 — G1이 똑같은 문자열을 합치는 법
- 이스케이프 분석 — 힙 할당을 없애는 JIT 최적화
- JIT 컴파일 튜닝 — 임계값과 컴파일러 제어
- 애너테이션 프로세싱 — 컴파일 시점에 코드 읽고 생성하기
- 커스텀 애너테이션 만들기 — @interface로 직접 선언하기
- 메타 애너테이션 — @Retention·@Target·@Documented·@Inherited
- 내장 애너테이션 — @Override·@Deprecated·@SuppressWarnings
- 애너테이션 기초 — 코드에 메타데이터 붙이기
- MethodHandles — 리플렉션보다 빠른 메서드 핸들
- 동적 프록시 — 런타임에 인터페이스 구현 만들기
- Class·Method·Field — 리플렉션 핵심 객체 다루기
- 리플렉션 기초 — 런타임에 타입을 들여다보기
- 모듈 마이그레이션 — classpath에서 module path로
- jmod — 모듈 패키징 포맷과 jmod 도구
- jlink — 모듈로 맞춤형 런타임 이미지 만들기
- 모듈 서비스 — provides/uses와 ServiceLoader
- requires와 exports — 모듈 의존과 공개 제어
- module-info.java — 모듈 선언 파일 작성하기
- Java 모듈 시스템 개요 — JPMS란 무엇인가
- JDK Mission Control — JFR 기록 분석
- JDK Flight Recorder — 저비용 상시 프로파일링
- 스레드 덤프 — 멈춘 스레드와 데드락 진단
- 힙 덤프 — 메모리 누수를 잡는 스냅샷 분석
- OutOfMemoryError — 종류별 원인과 진단
- Stop-The-World — GC가 애플리케이션을 멈추는 순간
- GC 로그 읽기 — Unified Logging으로 진단하기
- GC 튜닝 — 수집기 선택과 힙 사이징 전략
- Shenandoah GC — Brooks 포인터와 동시 압축
- ZGC — 컬러드 포인터와 초저지연 수집
- G1 GC — 리전 기반 수집기와 정지 시간 목표
- CMS GC — 동시 수집의 시작과 그 종말
- Parallel GC — 처리량을 위한 병렬 수집기
- Serial GC — 가장 단순한 단일 스레드 수집기
- 세대별 GC — 약한 세대 가설과 Minor/Major GC
- GC 기본 알고리즘 — Mark-Sweep, Mark-Compact, Copying
- 가비지 컬렉션 개요 — 도달 가능성과 GC의 큰 그림
- JVM 메모리 모델 — GC를 이해하기 위한 지도
- 레거시 Date·Calendar의 함정과 마이그레이션
- TemporalAdjusters — 상대 날짜 계산의 도구상자
- DateTimeFormatter — 날짜·시간 포맷팅과 파싱
- Instant와 Duration — 기계의 시간과 시간의 양
- ZonedDateTime — 타임존을 품은 날짜와 시간
- LocalDateTime — 날짜와 시각의 결합
- LocalDate와 LocalTime — 날짜와 시각 다루기
- java.time 개요 — 모던 날짜·시간 API의 설계 철학
- Java LTS 마이그레이션 로드맵
- Java 21 핵심 기능 정리 (LTS)
- Java 18~20 브리지 — Virtual Threads Preview와 UTF-8 기본화
- Java 17 핵심 기능 정리 (LTS)
- Java 12~16 브리지 — Switch 표현식·Text Block·Records·Pattern Matching
- Java 11 핵심 기능 정리
- Java 9·10 주요 변경 사항 브리지
- Java 8 핵심 기능 총정리
- Virtual Thread 운영 모범 사례
- Virtual Thread Pinning 심화 분석과 해결 전략
- Structured Concurrency로 안전한 비동기 구조 만들기
- Virtual Thread 생성과 관리 심화
- 플랫폼 스레드 vs Virtual Thread 심층 비교
- Virtual Threads: Java 21의 경량 동시성 혁신
- CompletableFuture 비동기 예외 처리 완전 정복
- CompletableFuture 조합 연산자 완전 정복
- CompletableFuture 기초와 비동기 파이프라인
- RecursiveTask와 RecursiveAction 완전 정복
- Fork/Join 프레임워크 완전 정복
- CompletionService: 완료 순서로 결과 수집하기
- Callable: 결과와 예외를 반환하는 작업 단위
- Future와 FutureTask: 비동기 결과 추적
- Executors 팩토리 메서드 완전 정리
- 스레드 풀 완전 분석: ThreadPoolExecutor 내부 동작
- ExecutorService와 Executor 프레임워크 개요
- ScopedValue: 가상 스레드 시대의 컨텍스트 전파
- ThreadLocal로 스레드별 상태 관리하기
- happens-before 규칙 완전 정복
- Java 메모리 모델(JMM) 완전 이해
- 라이브락과 기아 현상: 교착 상태의 사촌들
- 교착 상태(Deadlock) 완전 분석과 예방 전략
- 스레드 안전 컬렉션 — ConcurrentHashMap부터 BlockingQueue까지
- Condition 변수로 구현하는 생산자-소비자 패턴
- StampedLock — 낙관적 읽기와 락 변환
- Lock 인터페이스 — ReentrantLock 완전 가이드
- Atomic 클래스 — Lock-Free 동기화
- volatile 키워드와 메모리 가시성
- synchronized 키워드 완전 분석 — 모니터 락과 메모리 가시성
- 스레드 우선순위와 데몬 스레드
- Java 스레드 생명주기 — 6가지 상태와 전이 조건
- Runnable과 Thread — 스레드 생성과 제어
- 스레드 기초 — 동시성 프로그래밍의 시작
- 레코드와 직렬화 — Record Serialization
- Java 직렬화의 함정 — 보안과 성능 문제
- Java 직렬화 — 객체를 바이트로
- AsynchronousFileChannel — 비동기 파일 I/O
- WatchService — 디렉터리 변경 감시
- NIO Selector — 단일 스레드 다중 채널 I/O
- NIO 채널과 버퍼 — 고성능 I/O의 핵심
- Path API — 경로 표현의 표준
- Files 클래스 — 파일 시스템 조작 완전 가이드
- BufferedReader/Writer — 버퍼링 IO와 줄 단위 처리
- 바이트 스트림과 문자 스트림 — InputStream/OutputStream, Reader/Writer 심화
- Java IO 개요 — 입출력 스트림 구조 이해하기
- 예외 처리 베스트 프랙티스 — 올바른 예외 설계 원칙
- RuntimeException 종류 — 주요 비검사 예외 완전 정리
- 예외 체이닝 — 원인 예외를 보존하는 방법
- 커스텀 예외 — 도메인에 맞는 예외 클래스 설계
- multi-catch — 여러 예외를 한 번에 처리하기
- try-with-resources — 자원 자동 해제의 모든 것
- try-catch-finally — 예외 처리 구문 완전 분석
- Checked vs Unchecked 예외 — 언제 무엇을 써야 하나
- 예외 처리 개요 — Java 예외 계층 구조와 설계 원칙
- Optional 안티패턴 — 잘못 사용하는 7가지 방법
- Optional 모범 사례 — 실무에서 올바르게 쓰는 방법
- Optional 메서드 완전 정리 — map·flatMap·filter·orElse
- Optional 생성 — of·empty·ofNullable 완전 분석
- Optional — null을 대체하는 안전한 값 컨테이너
- 불변 객체(Immutable Objects) — 안전한 설계의 기초
- 커링(Currying) — 다중 인자 함수를 단계적 함수로 분해하기
- 함수 합성 — andThen·compose·Predicate 조합 완전 정리
- BiFunction·BiPredicate·BiConsumer — 두 입력 처리
- 내장 함수형 인터페이스 — Function·Consumer·Supplier·Predicate
- 메서드 참조 — 4가지 유형 완전 정리
- 람다 표현식 — 문법·특성·익명 클래스와의 차이
- Stream vs for 루프 — 성능·가독성·선택 기준 완전 비교
- Stream 주의사항 — 흔한 함정 8가지와 해결책
- Stream 병렬 처리 — parallelStream과 ForkJoin 풀
- Stream flatMap — 중첩 스트림 평탄화와 활용 패턴
- groupingBy 심화 — 다운스트림 Collector 조합과 다중 레벨 그루핑
- Stream Collectors — joining·groupingBy·partitioningBy·toMap
- Stream 종료 연산 — collect·reduce·forEach·count·find·match
- Stream 중간 연산 — filter·map·flatMap·distinct·sorted·peek
- Stream 생성 — of·iterate·generate·Builder·파일·정규식
- Stream API 개요 — 파이프라인 구조와 지연 평가
- 컬렉션 프레임워크 모범 사례 — 선택·초기화·성능·안전
- 불변 컬렉션 — List.of·Map.of·Set.of와 copyOf
- Arrays 유틸리티 — 정렬·검색·복사·스트림 변환
- Collections 유틸리티 — 정렬·검색·동기화 래퍼
- PriorityQueue — 우선순위 큐의 힙 구조와 활용
- Queue와 Deque — 큐와 양방향 큐 인터페이스
- ConcurrentHashMap — 고성능 동시성 맵
- TreeMap — 정렬과 범위 쿼리를 지원하는 맵
- LinkedHashMap — 순서를 기억하는 맵
- HashMap — 해시 맵의 내부 구조와 성능
- TreeSet — 정렬과 범위 쿼리를 지원하는 Set
- LinkedHashSet — 삽입 순서를 유지하는 Set
- HashSet — 해시 기반 중복 없는 컬렉션
- Vector와 Stack — 레거시 스레드 안전 컬렉션
- LinkedList — 이중 연결 리스트의 구조와 실전 활용
- List와 ArrayList — 순서 있는 컬렉션의 핵심
- 컬렉션 프레임워크 개요 — Java Collections의 전체 구조
- 제네릭 함정 — 흔한 실수와 주의사항
- 타입 소거 — 런타임의 제네릭 타입
- PECS 원칙 — Producer Extends, Consumer Super
- 와일드카드 — ? 타입의 유연성
- 경계 타입 파라미터 — extends와 super로 범위 제한
- 제네릭 메서드 — 메서드 수준의 타입 매개변수
- 제네릭 클래스 — 타입 매개변수를 가진 클래스 설계
- Java 제네릭 완전 정복 — 타입 매개변수의 기초
- Java 불변 객체 — Immutable Object 설계와 활용
- Java Comparable과 Comparator — 자연 순서와 커스텀 정렬
- Java finalize() 제거 — try-with-resources와 Cleaner 대안
- Java clone() — Cloneable과 깊은 복사·얕은 복사
- Java toString() — 의미 있는 문자열 표현 만들기
- Java equals()와 hashCode() — 계약과 올바른 구현
- Java Object 클래스 — 모든 클래스의 공통 조상
- Java Record 패턴 — 중첩 구조 분해와 패턴 매칭
- Java Record — 불변 데이터 클래스를 한 줄로 선언하기
- Java Sealed 클래스 — permits로 상속 계층 봉인하기
- Java 다중 상속 — default 메서드와 다이아몬드 문제 해결
- Java 마커 인터페이스 — 빈 몸체로 타입을 마킹하는 설계 패턴
- Java 함수형 인터페이스 — @FunctionalInterface와 람다의 기반
- Java 인터페이스 private 메서드 — 구현 캡슐화와 중복 제거
- Java 인터페이스 static 메서드 — 팩토리와 유틸리티 설계
- Java default 메서드 완전 정복 — 인터페이스의 진화
- Java 인터페이스 완전 정복 — 계약과 다중 구현
- Java 추상 클래스 완전 정복 — abstract와 설계 계약
- Java 다형성 완전 정복 — 업캐스팅과 동적 디스패치
- Java super 키워드 완전 정복 — 생성자 체이닝과 부모 멤버 접근
- Java 메서드 오버라이딩 완전 정복 — @Override와 재정의 규칙
- Java 상속 완전 정복 — extends로 코드를 물려받는 법
- Java getter와 setter 완전 정복 — 올바른 설계와 안티패턴
- Java 캡슐화 완전 정복 — 정보 은닉과 불변식 보호
- Java 접근 제어자 완전 정복 — public, protected, default, private
- Java final 키워드 완전 정복 — 불변 변수·메서드·클래스
- Java static 멤버 완전 정복 — 클래스 레벨 필드와 메서드
- Java 메서드 오버로딩 완전 정복 — 같은 이름, 다른 시그니처
- Java this 키워드 완전 정복 — 인스턴스 자기 참조
- Java 생성자 완전 정복 — 기본·매개변수·오버로딩·체이닝
- Java 필드와 메서드 — 객체의 상태와 행동 정의
- Java 클래스와 객체 — 설계도와 실체의 세계
- Java Text Block 완전 정복 — 여러 줄 문자열 처리
- Java StringBuilder · StringBuffer 완전 정복 — 가변 문자열의 모든 것
- Java String Pool 완전 정복 — intern, 리터럴, 메모리 구조
- Java String 완전 정복 — 불변 객체, 주요 메서드, 비교의 모든 것
- Java 다차원 배열 완전 정복 — 2D 배열부터 가변 배열까지
- Java 배열 완전 정복 — 선언부터 Arrays 유틸리티까지
- Java 패턴 매칭 switch 완전 정리
- Java switch 표현식 완전 정리
- Java 제어 흐름(Control Flow) 완전 정리
- Java 연산자(Operator) 완전 정리
- Java 타입 변환(Type Conversion) 완전 정리
- Java 참조형(Reference Types) 완전 정리
- Java 기본형(Primitive Types) 완전 정리
- Java 변수와 리터럴 완전 정리
- Hello, Java World — 첫 번째 Java 프로그램
- JVM Class File 포맷 완전 해부
- JVM 바이트코드 명령어 완전 정복
- JVM 바이트코드 기초: 소스에서 명령어까지
- JVM 티어드 컴파일: C1·C2 협력 전략과 실전 튜닝
- JVM JIT 컴파일 심화: C1·C2 컴파일러와 최적화 기법
- JVM 실행 엔진: Interpreter와 JIT 컴파일러
- JVM Heap 구조 완전 분석
- JVM 런타임 데이터 영역
- 클래스 로더 위임 모델 심화
- JVM 클래스 로더 시스템
- JVM 아키텍처 완전 해부
- JShell로 Java 코드 즉시 실행하기
- Javadoc으로 API 문서 작성하기
- 클래스패스와 모듈패스
- JDK 내장 도구 완전 정복
- SDKMAN으로 JDK 설치하기
- JDK · JRE · JVM — 세 개념의 차이
- JDK 벤더 배포판 완전 가이드
- Write Once, Run Anywhere — Java의 플랫폼 독립성
- Java LTS와 릴리즈 사이클
- Java 플랫폼 에디션 — SE · ME · Jakarta EE
- Java 역사 (1991 ~ 2023+)
- Java란 무엇인가
Python
맨 처음 ↓- 왈러스 연산자 vs 일반 대입
- 얕은 복사 vs 깊은 복사
- 리스트 vs 튜플, 언제 무엇을 쓸까
- 덕 타이핑 vs isinstance — 타입을 묻지 않는 법
- 파이썬다운 코드란? — Pythonic vs Non-Pythonic
- 부동소수점의 함정
- 클로저의 늦은 바인딩 함정
- 가변 기본 인자의 함정
- 인코딩·디코딩 에러 다루기
- 순환 임포트 해결하기
- 의존성 취약점 스캔: pip-audit로 안전한 패키지 관리
- eval과 exec의 위험성
- pickle의 보안 위험: 신뢰할 수 없는 데이터를 풀지 마라
- bcrypt로 비밀번호 안전하게 저장하기
- secrets vs random: 보안에 안전한 난수 만들기
- SQLAlchemy ORM: 파이썬으로 SQL 다루기
- Celery: 무거운 작업을 백그라운드로
- marshmallow: 스키마 기반 직렬화
- Pydantic: 데이터 검증을 타입으로
- requests vs httpx: HTTP 클라이언트 고르기
- Jinja2 템플릿: 데이터를 HTML로
- uvicorn과 ASGI: 비동기 서버의 토대
- FastAPI 기초: 타입 힌트로 만드는 API
- Django ORM 기초: 모델로 DB 다루기
- Flask 입문: 가장 작은 웹 앱부터
- pandas 시계열: 날짜 인덱스와 리샘플링
- 대용량 CSV: 메모리 안에서 다 읽지 않기
- 데이터 클리닝: 결측치와 이상치 다루기
- scikit-learn 입문: fit과 predict의 흐름
- Jupyter Notebook: 셀 단위로 탐색하기
- matplotlib 기초: 첫 그래프 그리기
- pandas merge: 표를 키로 이어 붙이기
- pandas groupby: 나누고 적용하고 합치기
- pandas DataFrame: 표 데이터의 기본 단위
- NumPy 기초: ndarray와 벡터화 연산
- icecream: print 디버깅을 견딜 만하게
- py-spy: 코드 수정 없는 샘플링 프로파일러
- tracemalloc: 메모리 할당을 추적하기
- memory_profiler: 줄 단위로 메모리 보기
- cProfile: 시간이 어디서 새는지 측정하기
- logging 설정: 로거 계층과 dictConfig
- logging 모듈: print를 졸업하는 법
- print 디버깅의 함정과 졸업
- breakpoint(): 디버거를 부르는 표준 한 줄
- pdb 기초: 파이썬 내장 디버거 시작하기
- 테스트 디스커버리: 도구가 테스트를 찾는 규칙
- doctest: 문서 속 예제를 테스트로
- Hypothesis로 시작하는 속성 기반 테스트
- tox와 nox: 여러 환경에서 자동으로 테스트하기
- 코드 커버리지: 테스트가 닿지 않은 곳 찾기
- mock과 monkeypatch: 의존성을 가짜로 바꾸기
- parametrize: 하나의 테스트를 여러 입력으로 펼치기
- pytest fixture: 테스트 준비물을 우아하게 주입하기
- pytest 기초: assert 한 줄로 쓰는 테스트
- unittest 기초: 표준 라이브러리로 시작하는 테스트
- 버전 고정과 lock 파일: 재현 가능한 빌드
- PyPI 배포: 내 패키지를 세상에 공개하기
- wheel vs sdist: 두 가지 배포 아티팩트
- setup.py vs pyproject.toml: 패키징 설정의 세대 교체
- pyproject.toml: 프로젝트 설정의 단일 표준
- uv: Rust로 다시 쓴 초고속 패키지 매니저
- PDM: 표준을 따르는 현대적 패키지 관리자
- Poetry: 의존성·환경·패키징을 한 도구로
- venv: 프로젝트마다 격리된 가상환경 만들기
- pip 기초: 패키지를 설치하고 관리하기
- Self 타입: 메서드 체이닝과 자기 참조
- 런타임 타입 검사: runtime_checkable과 그 한계
- mypy와 pyright: 두 정적 타입 검사기 비교
- ParamSpec: 데코레이터의 시그니처를 보존하기
- typing.Protocol: 상속 없는 구조적 타이핑
- TypedDict: 딕셔너리에 구조를 부여하기
- Literal과 Final: 값과 불변을 타입으로 표현하기
- Union과 Optional: 여러 타입을 허용하기
- 제네릭: TypeVar와 Generic으로 타입을 재사용하기
- 타입 힌트 입문: 파이썬에 타입을 더하는 법
- Lock, RLock, Semaphore
- 스레드 안전 Queue
- Trio와 AnyIO
- aiohttp와 httpx
- 블로킹 I/O와 asyncio
- async / await 문법
- asyncio 작업 취소
- asyncio Task와 gather
- asyncio 이벤트 루프
- asyncio 기초
- ThreadPoolExecutor
- ProcessPoolExecutor
- multiprocessing 기초
- threading 모듈
- GIL — 전역 인터프리터 잠금
- 비동기 컨텍스트 매니저
- ExitStack — 동적 컨텍스트 매니저 스택
- contextlib.suppress와 redirect
- contextlib.contextmanager 데코레이터
- 컨텍스트 매니저 클래스
- deprecated 경고 데코레이터
- 캐시 데코레이터: lru_cache와 cache
- property 데코레이터 완전 이해
- 타입 힌트와 데코레이터
- 상태를 가진 데코레이터
- 중첩 데코레이터와 적용 순서
- 클래스로 만드는 데코레이터
- 인자를 받는 데코레이터 만들기
- functools.wraps: 데코레이터와 메타데이터 보존
- 데코레이터의 본질: 함수를 감싸는 함수
- 부작용 격리 패턴: 순수와 불순을 분리하는 설계
- 함수형 데이터 파이프라인: 실전 설계 패턴
- 메모이제이션 패턴: 계산 결과 캐싱 전략
- 꼬리 재귀와 재귀 깊이 제한: sys.setrecursionlimit 완전 이해
- 파이프 패턴: 데이터를 흘리는 함수형 파이프라인
- toolz와 cytoolz: Python 함수형 프로그래밍 라이브러리
- 커링과 부분 적용: functools.partial 완전 정복
- functools.reduce: 시퀀스를 단일 값으로 접기
- 순수 함수(Pure Functions): 부작용 없는 함수 설계
- 불변성(Immutability): Python에서 변하지 않는 것들
- 무한 이터레이터: count, cycle, repeat와 islice 활용
- itertools 핵심: chain, product, combinations
- 비동기 제너레이터: async def + yield의 결합
- 비동기 이터레이터: __aiter__와 __anext__ 프로토콜
- 제너레이터 제어: send(), throw(), close() 완전 정복
- 제너레이터 기반 코루틴: send()와 초기 코루틴 패턴
- yield from: 서브제너레이터 위임과 투명한 전달
- 제너레이터 함수: yield로 만드는 지연 이터레이터
- iter()와 next() 내장 함수 심층 탐구
- Python 이터레이터 프로토콜: __iter__와 __next__ 완전 이해
- 예외 처리 모범 사례와 안티패턴
- traceback 모듈로 예외 정보 완전 제어하기
- warnings 모듈: 경고를 오류처럼 다루기
- 예외 그룹과 except*: Python 3.11의 새 문법
- 예외 연결: __cause__와 __context__
- 커스텀 예외 클래스 설계하기
- Python 예외 계층 구조 완전 탐구
- raise와 raise from: 예외 재발생과 원인 연결
- try / except / else / finally 완전 정복
- Python 예외 처리 기초: try, except, 그리고 예외 객체
- 줄 끝 문자: \n·\r\n·\r과 크로스 플랫폼 처리
- mmap: 메모리 맵 파일로 대용량 처리
- pathlib로 파일 읽고 쓰기: 현대적인 파일 I/O
- seek·tell: 파일 포인터로 임의 위치 읽기·쓰기
- write·flush·버퍼: 파일 쓰기의 내부 동작
- readline vs readlines: 파일 읽기 방법 완전 비교
- 파일 인코딩: UTF-8부터 EUC-KR까지
- 텍스트 vs 이진 모드: 개행 문자와 인코딩의 차이
- with 문과 컨텍스트 매니저: 자원을 안전하게 관리하는 법
- 파일 열기 모드: open() 완전 정리
- hashlib: 해시 함수와 암호화 기초
- uuid: 유일 식별자 생성
- sqlite3: 내장 관계형 데이터베이스
- pickle: Python 객체 직렬화
- csv 모듈: CSV 파일 읽기와 쓰기
- json 모듈: JSON 직렬화와 역직렬화
- operator 모듈: 연산을 함수로 다루기
- functools.partial: 인자를 고정한 함수 만들기
- functools.lru_cache: 메모이제이션 캐싱
- itertools 기초: 조합형 이터레이터 완벽 활용
- time 모듈 vs datetime: 언제 무엇을 쓸까
- zoneinfo로 타임존 다루기
- datetime 기초: 날짜와 시간 다루기
- tempfile: 임시 파일과 디렉토리 안전하게 다루기
- glob과 fnmatch: 파일 패턴 매칭
- subprocess: 외부 프로세스 실행하기
- shutil: 고수준 파일 복사·이동·압축
- sys 모듈: Python 인터프리터와 직접 대화하기
- pathlib으로 경로 다루기: 객체지향 파일시스템 API
- os 모듈 완전 정복: 파일·디렉토리·환경변수 다루기
- 이름 맹글링과 private 네임: _, __ 접두사 완전 정리
- 조건부 임포트: 선택적 의존성과 폴백 처리
- 모듈 캐싱과 sys.modules: 한 번만 로드되는 이유
- if __name__ == "__main__" 이디엄 완전 정복
- importlib로 동적 임포트: 런타임 모듈 로딩
- 순환 임포트: 원인, 동작 원리, 해결 패턴
- 네임스페이스 패키지: __init__.py 없는 패키지
- 패키지와 __init__.py: 역할과 설계 패턴
- 절대 임포트 vs 상대 임포트: 언제 무엇을 써야 하나
- Python 모듈 검색 경로: sys.path 완전 정복
- __slots__: 메모리 효율적인 클래스
- frozen dataclass: 불변 데이터 클래스
- @dataclass: 보일러플레이트 없는 데이터 클래스
- Protocol: 구조적 서브타이핑
- 추상 기반 클래스: ABC와 abstractmethod
- super(): 협력적 다중 상속의 핵심
- 다중 상속과 MRO: 다이아몬드 문제 해결
- 단일 상속: 코드 재사용의 기본
- @classmethod와 @staticmethod: 세 가지 메서드 종류
- @property 데코레이터: 캡슐화된 속성 접근
- 컨텍스트 매니저 프로토콜: __enter__와 __exit__
- 산술 연산 메서드: __add__, __mul__ 외
- 비교 메서드: __lt__, __le__, __gt__, __ge__
- __eq__와 __hash__: 동등성과 해시 계약
- __repr__ vs __str__: 객체를 문자열로
- 매직 메서드(Special Methods) 개요
- __init__ vs __new__: 객체 생성의 두 단계
- self 키워드 완전 이해
- 인스턴스 속성 vs 클래스 속성
- 클래스 기초: 사용자 정의 타입 만들기
- array 모듈: 타입 고정 배열
- bisect: 이진 탐색으로 정렬 유지
- heapq: 파이썬 힙과 우선순위 큐
- collections.namedtuple: 이름 있는 튜플
- collections.OrderedDict: 순서 보장 딕셔너리
- collections.defaultdict: KeyError 없는 딕셔너리
- collections.Counter: 빠른 빈도 분석
- collections.deque: 양방향 큐의 모든 것
- sorted vs sort: 정렬 함수 완벽 비교
- map·filter·reduce 완전 이해
- 파이썬 zip과 enumerate 완전 활용
- 파이썬 제너레이터 표현식과 지연 평가
- 파이썬 집합 컴프리헨션과 frozenset
- 파이썬 딕셔너리 컴프리헨션 — 데이터 변환의 핵심 도구
- 파이썬 리스트 컴프리헨션 완전 정복
- 순수 함수 vs 부수 효과 — 파이썬에서의 함수형 사고
- 파이썬 콜 스택과 트레이스백 읽기
- 파이썬 함수 어노테이션 완전 가이드
- 파이썬 고차 함수 완전 정복 — map, filter, sorted와 직접 만들기
- 파이썬의 일급 함수 — 함수를 값처럼 다루기
- 재귀 깊이 제한: sys.setrecursionlimit과 스택 오버플로
- 클로저: 함수가 환경을 기억하는 방법
- 람다 함수: 익명 함수의 용법과 한계
- 여러 값 반환하기: 튜플 언패킹과 Python다운 반환
- 위치 전용 인수: / 슬래시로 인터페이스 강화하기
- 키워드 전용 인수: * 이후 매개변수 강제하기
- *args와 **kwargs: 가변 인수 완전 정리
- 기본 인수의 함정: 가변 객체를 기본값으로 쓰면 안 되는 이유
- 위치 인수와 키워드 인수: Python 인수 전달 방식의 기본
- Python 함수 정의: def 키워드로 코드를 묶다
- 루프 함정: Python 루프에서 흔히 만나는 버그와 해결책
- pass 키워드: 아무것도 하지 않는 것의 역할
- 바다코끼리 연산자 :=: 할당 표현식
- 조건 표현식: x if 조건 else y 삼항 연산자
- match 문: Python 3.10 구조적 패턴 매칭
- 루프의 else: break 없이 완주했을 때만 실행되는 블록
- break와 continue: 루프 흐름 세밀하게 제어하기
- while 루프: 조건 기반 반복과 무한 루프 제어
- for 루프: 반복 가능 객체 순회의 모든 것
- if / elif / else: Python 조건문 완전 정복
- 해시와 동등성: __hash__와 __eq__의 관계
- 동등성 vs 동일성: == 와 is 의 차이
- 참·거짓값(Truthy/Falsy): Python 조건식 완전 이해
- 타입 변환: int, str, float, list 상호 변환
- 집합과 frozenset: 중복 없는 컬렉션
- 딕셔너리 기초: 키-값 매핑의 모든 것
- 튜플: 불변 시퀀스의 힘과 언패킹 패턴
- 리스트 기초: Python의 만능 순서형 자료구조
- None: Python의 '없음'을 나타내는 단 하나의 값
- bytes와 bytearray: 이진 데이터를 다루는 두 가지 방법
- 문자열 메서드: split, join, replace와 친구들
- f-string: 파이썬 문자열 포매팅의 정석
- 문자열 기초: 생성, 인덱싱, 슬라이싱
- bool과 Truthiness: 참과 거짓을 판별하는 방법
- 숫자 타입: int, float, complex
- 인코딩과 UTF-8: Python이 텍스트를 다루는 방식
- 셔뱅(Shebang)과 스크립트 실행 권한
- 모듈과 import: 코드를 나누고 재사용하는 방법
- 스크립트 vs REPL: Python 실행 방식의 차이
- input()과 print(): 표준 입출력 완전 정리
- 들여쓰기: Python이 공백을 문법으로 삼은 이유
- 주석 완전 정복: 좋은 주석과 나쁜 주석
- Hello, World! Python 첫 프로그램 해부하기
- PEP 8 스타일 가이드: 읽기 쉬운 코드의 기준
- The Zen of Python: PEP 20이 말하는 아름다운 코드
- pyenv로 Python 버전 마스터하기
- CPython과 PyPy: Python 구현체의 세계
- Python 2 vs 3: 왜 모두가 3으로 넘어왔는가
- Python의 탄생과 역사: Guido에서 3.12까지
- Python이란 무엇인가? 언어의 본질을 파악하다
Git
맨 처음 ↓- 비대해진 저장소 용량 줄이기: gc부터 히스토리 재작성까지
- Fast-forward only 정책으로 선형 히스토리 유지하기
- 머지 커밋 revert의 함정과 해결
- 파일명 대소문자 문제 다루기
- 줄바꿈(CRLF/LF) 문제 깔끔하게 해결하기
- 히스토리에 유출된 비밀정보 제거하기
- 대용량 바이너리를 실수로 커밋했을 때
- 엉뚱한 브랜치에 커밋했을 때 바로잡기
- 이미 푸시한 커밋을 안전하게 되돌리기
- 마지막 커밋 되돌리기: amend · reset · revert 골라 쓰기
- git range-diff: 리베이스 전후 커밋을 짝지어 비교하기
- git archive: 저장소를 아카이브로 내보내기
- git mailmap: 흩어진 작성자 신원을 하나로 통합하기
- git apply: 커밋 없이 작업 트리에만 패치 적용하기
- git diff --stat: 변경 요약 한눈에 보기
- git am: 메일박스 패치를 커밋으로 되살리기
- git diff --word-diff: 단어 단위 차이 보기
- git format-patch: 커밋을 패치 파일로 만들어 공유하기
- git log --grep: 커밋 메시지로 검색하기
- git bundle: 저장소를 단일 파일로 묶어 오프라인에서 주고받기
- git log -S/-G: 피카악스로 코드 변경 추적
- git bisect run: 테스트로 버그 커밋 자동 추적
- GitHub Secrets: 민감 정보 안전하게 관리
- Protected Branch: 브랜치 보호 규칙 설정
- GitHub Pages: 정적 사이트 배포하기
- GitHub CLI(gh): 터미널에서 GitHub 다루기
- Fork & Pull Request 워크플로우: 오픈소스 기여 흐름
- GitHub Projects: 칸반으로 이슈와 PR 관리하기
- GitHub Issues: 작업과 버그를 추적하는 법
- GitHub Actions로 PR 검사 자동화하기
- GitHub Actions 기초: 워크플로우 자동화 첫걸음
- CODEOWNERS: 코드 영역별 자동 리뷰어 지정
- Suggested Changes: 리뷰에서 바로 코드 고쳐주기
- GitHub 리뷰 타입: Comment·Approve·Request changes
- Draft Pull Request: 준비 중인 작업을 안전하게 공유하기
- GitHub Pull Request 기초: 변경을 제안하는 방법
- Changelog 자동 생성: 릴리즈 노트를 코드로
- Semantic Release: 자동 버전 관리와 릴리즈
- Merge vs Rebase: 팀에 맞는 병합 정책 고르기
- 이슈 템플릿으로 버그 리포트와 기능 요청 구조화하기
- PR 템플릿으로 일관된 PR 작성하기
- 코드 리뷰 흐름: PR에서 머지까지
- Branch Protection Rules: 실수 방지 안전망
- Monorepo vs Polyrepo: 어떤 저장소 구조를 선택할까
- Trunk-Based Development: 브랜치 없이 빠르게
- GitLab Flow: 환경 브랜치로 안전하게 배포하기
- GitHub Flow: 단순하고 빠른 브랜치 전략
- Gitflow release와 hotfix 브랜치
- Gitflow feature 브랜치 워크플로우
- Gitflow: 브랜치 전략 개요
- commitlint: 커밋 메시지 형식 자동 검증
- Conventional Commits: 커밋 메시지 표준 형식
- lint-staged: 변경 파일만 골라서 lint하기
- Husky: Node.js 프로젝트의 Git 훅 관리
- 서버 사이드 훅: pre-receive, update, post-receive
- post-merge 훅: 머지 후 자동화 작업 구성
- pre-push 훅: push 전 테스트와 브랜치 보호
- commit-msg 훅: 커밋 메시지 형식 자동 검증
- pre-commit 훅: 커밋 전 품질 게이트 구축하기
- Git Hooks 개요: 자동화의 시작점
- Git 공급망 보안(Supply Chain Security): 코드 신뢰 체인 구축하기
- Token vs Password: GitHub 인증 방식 변천사와 PAT 관리
- Git Credential Helper: 인증 정보 안전하게 저장하기
- SSH vs HTTPS: Git 원격 인증 프로토콜 선택 가이드
- SSH 키 생성과 GitHub 등록: 비밀번호 없이 인증하기
- git verify-commit / verify-tag: 서명 검증하기
- git tag -s: 태그에 서명 추가하기
- git commit -S: 커밋에 GPG/SSH 서명 추가하기
- Git GPG 서명 설정: 커밋 신원 보증하기
- Git Plumbing vs Porcelain: 명령어 계층 이해하기
- git update-ref: 참조를 직접 수정하는 plumbing 명령
- git rev-parse: 참조를 SHA로 변환하는 범용 도구
- git hash-object: 파일을 직접 오브젝트로 만들기
- git cat-file: 오브젝트 내용을 직접 읽는 plumbing 명령
- Git Index 파일: 스테이징 영역의 실체
- Git Delta 압축: pack 파일 내 오브젝트 저장 원리
- Git Packfile 내부 구조: 헤더·인덱스·델타 압축
- Git Loose 오브젝트 vs Pack 파일: 오브젝트 저장 방식
- Git packed-refs: ref를 압축 저장하는 파일
- Git HEAD의 본질: symbolic ref와 detached HEAD
- Git Refs 내부 구조: .git/refs/ 디렉터리
- Git SHA-1 vs SHA-256: 해시 알고리즘 전환
- Git Tag 오브젝트: annotated tag의 내부 구조
- Git Commit 오브젝트: 커밋 내부 구조
- Git Tree 오브젝트: 디렉터리 구조의 저장 방식
- Git Blob 오브젝트: 파일 내용의 저장 단위
- Git 오브젝트 모델: blob·tree·commit·tag
- Git 줄 끝 변환: CRLF와 LF 혼용 문제 완전 해결
- Git에서 빈 디렉터리 유지하기: .gitkeep과 .gitignore 활용
- 전역 gitignore: 모든 저장소에 적용되는 무시 규칙
- .gitignore 패턴 문법 완전 정복
- .gitattributes 완전 정복
- Git LFS 마이그레이션: 히스토리 속 파일을 LFS로 전환
- Git LFS 트래킹 설정과 해제
- Git LFS 기초: 대형 파일을 Git으로 관리하기
- Git 대용량 저장소 관리 팁
- Git Shallow Clone vs Full Clone: 언제 무엇을 쓸까
- Git Partial Clone: 필요한 오브젝트만 다운로드
- Git Sparse Checkout: 필요한 디렉터리만 체크아웃
- Git Worktree 멀티 브랜치 워크플로
- Git Worktree 기초: 하나의 저장소, 여러 작업 디렉터리
- Git 서브트리 기초: 외부 저장소를 디렉터리로 병합
- Git 서브모듈 vs 서브트리: 무엇을 선택할까
- Git 서브모듈 주의사항과 함정
- Git 서브모듈 init과 update: 설정과 동기화
- Git 서브모듈 기초: 저장소 안의 저장소
- git lost-found로 고립 객체 찾기
- Git 저장소 손상 복구하기
- 고아 커밋 복구하기
- 삭제된 브랜치 복구하기
- Git dangling objects 이해와 처리
- git gc로 저장소 최적화하기
- git fsck로 저장소 무결성 검사하기
- git bisect skip으로 불량 커밋 건너뛰기
- git bisect run으로 버그 탐색 자동화하기
- git bisect로 버그 커밋 이진 탐색하기
- git reflog로 브랜치 복구하기
- git reflog로 커밋 복구하기
- git reflog — 되돌린 이력까지 모두 기록
- git stash 주의사항과 함정
- git stash vs WIP 커밋 — 임시 저장 전략 비교
- git stash branch — 스태시를 새 브랜치로 변환
- git stash --keep-index — 스테이징 유지하며 저장
- git stash와 미추적 파일 — untracked 포함 저장
- git stash drop과 clear — 스태시 삭제
- git stash pop과 apply — 복원 방식의 차이
- git stash list와 show — 스태시 목록 확인
- git stash — 변경사항 임시 저장
- 히스토리 재작성 전 반드시 알아야 할 것들
- git 커밋 작성자 일괄 수정
- git revert — 머지 커밋 되돌리기
- git revert — 안전하게 커밋 되돌리기
- BFG Repo-Cleaner — 대용량·비밀 파일 제거
- git filter-repo — 히스토리 완전 재작성
- git rebase -i — drop으로 커밋 삭제
- git rebase -i — 커밋 순서 바꾸기
- git rebase -i — squash와 fixup으로 히스토리 정리
- git commit --amend 주의사항과 실수 복구
- git commit --amend — 마지막 커밋 수정
- Semantic Versioning과 Git 태깅
- 릴리스 워크플로 — 태그 기반 배포 자동화
- git describe — 버전 자동 생성
- 태그 삭제 — 로컬과 원격
- 태그 Push와 Fetch — 원격 동기화
- 태그 목록 조회와 생성 패턴
- Lightweight 태그 — 단순한 포인터의 모든 것
- 주석 태그 심층 분석 — git tag -a
- Git 태그의 두 종류: Lightweight vs Annotated
- 자격 증명 헬퍼로 인증 자동화하기
- Pull Request 기본 흐름
- Fork & Clone 워크플로우
- 여러 원격 저장소 관리하기
- 업스트림 설정으로 push/pull 자동화하기
- 원격 추적 브랜치 이해하기
- Bare 저장소란 무엇인가 — git clone --bare
- 얕은 복제로 빠르게 시작하기 — git clone --depth
- 원격 브랜치와 태그 삭제하기
- 태그 push — 로컬 태그를 원격에 올리기
- push --force-with-lease — 안전한 강제 푸시
- git push --force의 위험성과 주의사항
- git push 기본 사용법
- pull --rebase — 깔끔한 히스토리 유지하기
- fetch --prune으로 삭제된 원격 브랜치 정리하기
- fetch와 pull의 차이 — 안전하게 동기화하기
- 원격 저장소 이름 변경과 삭제
- git remote add — 원격 저장소 추가하기
- Cherry-pick: 특정 커밋만 골라서 적용하기
- 원격 저장소(Remote)의 본질과 역할
- git stash 적용 중 충돌 처리
- Rebase vs Merge: 어떤 것을 선택해야 할까
- Cherry-pick 충돌 심화: 연속 픽과 범위 픽 처리
- rebase --onto: 특정 범위 커밋만 옮기기
- Interactive Rebase: 커밋 수정·합치기·순서 바꾸기
- Rebase 중 충돌 처리: 커밋별 해결 전략
- Rebase 기초: 커밋을 새 베이스 위에 재적용하기
- rerere: 충돌 해결책을 기억하고 재사용하기
- Merge 전략: ort, recursive, octopus, ours 비교
- 충돌 해결 전략: -X ours와 -X theirs
- git mergetool로 시각적으로 충돌 해결하기
- Squash Merge: 커밋을 하나로 압축해 병합하기
- --no-ff 옵션: 머지 커밋을 항상 남기는 이유
- 충돌 마커 해설: <<<<<<< , =======, >>>>>>>
- 3-Way Merge: 갈라진 브랜치를 합치는 원리
- Git 충돌의 해부: 언제, 왜 발생하는가
- Cherry-pick 충돌: 발생부터 해결까지
- Fast-Forward Merge: 직선 히스토리로 브랜치 병합하기
- Detached HEAD: 브랜치 없는 커밋 상태 이해하기
- git checkout vs git switch: 브랜치 전환 명령 비교
- 브랜치 네이밍 컨벤션: 팀이 합의해야 할 규칙들
- 추적 브랜치(Tracking Branch): 로컬과 원격의 연결 고리
- 브랜치 이름 변경과 삭제: git branch -m/-d/-D
- git branch: 브랜치 목록 조회와 생성
- 브랜치의 본질: Git 브랜치가 가볍고 빠른 이유
- git shortlog: 기여자별 커밋 통계 요약하기
- git grep: 워킹 트리와 히스토리에서 패턴 검색하기
- git blame: 코드 한 줄의 저자와 커밋 추적하기
- git show: 커밋 상세 내용과 오브젝트 조회하기
- git log 필터: 저자·날짜·키워드로 커밋 검색하기
- git log --graph: 브랜치 분기를 ASCII 그래프로 시각화하기
- git log --format: 커밋 로그 출력 형식 커스터마이징
- git log 기초: 커밋 히스토리 탐색하기
- git diff 두 점(..)과 세 점(...): 브랜치 간 비교의 차이
- git diff --staged: 커밋 전 인덱스 변경 내용 검토하기
- git diff: 워킹트리·인덱스·커밋 간 변경 내용 비교하기
- git clean: 추적되지 않는 파일을 한 번에 정리하기
- git rm / git mv: 파일 삭제와 이동을 히스토리에 남기는 법
- git reset: soft·mixed·hard 세 가지 모드 완전 정복
- git restore: 파일을 원하는 상태로 되돌리기
- git add -u: 추적 중인 파일만 골라 스테이징하기
- git add -p: 변경을 헝크 단위로 골라 스테이징하기
- git add 기본: 스테이징을 정확하게 제어하기
- 빈 커밋: 히스토리에 메모를 남기는 기술
- git status 읽기: 저장소 상태를 한눈에 파악하기
- 커밋 메시지 컨벤션: 좋은 커밋 메시지의 조건
- 커밋 객체 해부: 내부 구조를 손으로 뜯어보기
- 첫 번째 커밋: 변경을 역사에 새기는 순간
- 스테이징 영역의 본질: 커밋을 조각하는 작업대
- Git의 세 가지 트리: 작업 디렉토리, 스테이징, HEAD
- git clone: 원격 저장소 복제하기
- git init: 새 저장소 초기화
- Git Alias: 단축 명령어로 워크플로 가속하기
- Git 전역 설정: 처음 딱 한 번 해두면 되는 것들
- Git 설치 가이드: macOS, Windows, Linux
- Git의 탄생과 역사
- 중앙집중식 vs 분산형 버전 관리
- 버전 관리란 무엇인가: Git을 시작하기 전에
Linux
맨 처음 ↓- systemd 서비스 실행 실패 진단
- 깨진 패키지 상태 복구
- SSH 설정 파손 복구
- 파일 시스템 읽기 전용 복구
- 종료 실패 — shutdown/reboot 멈춤 트러블슈팅
- 로케일 및 인코딩 문제 — 한글 깨짐 트러블슈팅
- 시간 동기화 문제 — NTP/chrony 트러블슈팅
- 프로세스 멈춤 — Hung Process 조사
- Segmentation Fault 조사 — 세그멘테이션 폴트 원인 분석
- Permission Denied — 권한 거부 트러블슈팅
- DNS 이름 해석 실패 트러블슈팅
- Network Unreachable — 네트워크 연결 불가 트러블슈팅
- Too many open files — 파일 디스크립터 한도 문제 해결
- 디스크 풀 문제 해결 — df·du·find로 공간 확보
- 로그인이 안 될 때 — 계정·PAM·쉘 문제 진단
- 복구 모드와 emergency 타겟 — 부팅 실패 시 살아남기
- 런레벨과 systemd 타겟 — SysV에서 systemd로의 전환
- dmesg와 부트 로그 — 커널 링 버퍼 읽기
- /proc/sys 완전 탐방 — 커널이 열어놓은 가상 파일시스템
- sysctl — 커널 파라미터를 런타임에 조정하기
- modprobe와 modinfo — 의존성을 고려한 모듈 관리
- 커널 모듈과 lsmod — 동적으로 확장되는 Linux 커널의 구조
- initramfs — 임시 루트 파일시스템의 역할과 커스터마이징
- GRUB 기초 — 부트로더 설정과 복구
- Linux 부팅 과정 — BIOS/UEFI에서 systemd까지
- iptables NAT와 Docker 네트워크 — 컨테이너 트래픽 흐름
- QEMU 개요 — 범용 에뮬레이터이자 가상화 가속기
- libvirt와 virsh — 가상화 통합 관리 API와 CLI
- KVM 가상화 — Linux 커널 내장 하이퍼바이저
- systemd-nspawn — systemd 내장 OS 컨테이너 런타임
- Podman 루트리스 컨테이너 — 데몬 없이 안전하게
- runc 상세 — OCI Runtime Spec과 컨테이너 생성 원리
- OverlayFS 상세 — 컨테이너 이미지 레이어 스토리지의 원리
- cgroups v1 vs v2 — 리소스 제한의 두 세대 비교
- Container Namespaces 상세 — 컨테이너 격리의 실제 구현
- OOM Killer — 메모리 부족 시 리눅스가 프로세스를 선택하는 방법
- Page Cache — 리눅스 메모리 캐시의 핵심 구조
- perf record/report — 리눅스 성능 분석의 스위스 아미 나이프
- Flame Graph — CPU 병목을 시각화하는 플레임 그래프
- eBPF 개요 — 커널을 재컴파일 없이 관찰하는 혁신적 기술
- lsof — 열린 파일과 소켓 한눈에 보기
- ltrace 기초 — 라이브러리 함수 호출 추적으로 동작 파악하기
- strace 기초 — 시스템 콜 추적으로 프로그램 내부 들여다보기
- 메모리 누수 조사 — valgrind·heaptrack·smaps로 원인 찾기
- 프로세스 CPU 프로파일링 — perf와 FlameGraph로 병목 찾기
- 디스크 IOPS와 지연 시간 — 스토리지 성능 측정과 분석
- FUSE — 사용자 공간에서 파일시스템 만들기
- CIFS/SMB 마운트 — 윈도우 공유 폴더를 리눅스에서 연결하기
- NFS 마운트 — 네트워크 파일시스템 공유와 연결
- tmpfs·procfs·sysfs — 메모리와 커널이 만드는 가상 파일시스템
- 심볼릭 링크의 함정 — 깨진 링크와 순환 참조 피하기
- 디스크 쿼터 — 사용자·그룹별 저장 공간 제한하기
- 루프백 마운트 — 파일을 블록 디바이스로 다루기
- Bind Mount — 디렉터리를 다른 경로에 재마운트하기
- 마운트 유형 완전 정리 — 블록·바인드·루프·tmpfs·NFS
- CVE 모니터링 — 취약점 추적과 패치 전략
- 권한 강화 — 최소 권한 원칙으로 공격 표면 줄이기
- LUKS — 리눅스 디스크 전체 암호화
- Secure Boot — 부팅 체인 검증으로 부트킷 막기
- auditd — 리눅스 감사 시스템 완전 정리
- 루트킷 탐지 — 숨은 침입자 찾기
- Port Knocking — 포트 숨겨두기로 공격 표면 줄이기
- fail2ban — 무차별 대입 공격 자동 차단
- AppArmor 기초 — 경로 기반 MAC으로 앱 격리하기
- SELinux 기초 — 강제 접근 제어(MAC) 입문
- X11 포워딩 — SSH로 원격 서버의 GUI 앱 실행하기
- mosh — 불안정한 네트워크에서의 SSH 대안
- screen & tmux — 터미널 멀티플렉서 완전 정리
- SCP vs rsync — 실무에서 무엇을 선택해야 하나
- rsync 옵션 완전 해설 — -avz부터 --partial까지
- SSH 터널 — 로컬·리모트·다이나믹 포워딩 완전 정리
- SCP vs SFTP — SSH 기반 파일 전송 완전 비교
- ssh-agent — 키 패스프레이즈 캐싱
- SSH config 파일 — 접속 설정 관리
- SSH 키 쌍 생성과 관리
- jq · yq — JSON/YAML 커맨드라인 처리
- comm · cmp — 파일 집합 연산과 바이너리 비교
- diff · patch — 파일 비교와 패치 적용
- wc · nl — 줄/단어/문자 세기와 행 번호
- tr · fold · fmt — 문자 변환과 줄 포맷
- sort · uniq — 정렬과 중복 제거
- cut · paste · join — 열 기반 텍스트 처리
- awk 내장 함수
- awk 필드와 레코드
- awk 기초
- sed 치환과 주소 지정
- sed 기초
- grep/egrep/fgrep 텍스트 검색
- ShellCheck: 쉘 스크립트 정적 분석
- set 옵션과 Strict Mode
- trap으로 시그널 처리와 정리
- Bash 파라미터 확장 완전 정복
- Bash 문자열 조작
- Bash 산술 연산
- Bash 프로세스 치환
- Bash Here Document와 Here String
- Bash getopts로 옵션 파싱
- Bash 위치 매개변수
- Bash 함수 완전 정복
- Bash 반복문 완전 정복
- Bash 조건문 완전 정복
- Bash 배열 완전 정복
- Bash 변수와 인용 부호
- Bash 셔뱅과 스크립트 실행 방식
- bpftrace — eBPF 기반 동적 추적 입문
- perf — 리눅스 성능 분석 기초
- iotop과 iftop — I/O·네트워크 실시간 모니터링
- free — 메모리 사용량 정확하게 읽기
- mpstat과 sar — CPU별 사용률과 히스토리 수집
- iostat — 디스크 I/O 통계와 성능 분석
- vmstat — 가상 메모리와 시스템 상태 통계
- uptime과 load average — 시스템 부하 읽기
- dmesg — 커널 링 버퍼와 부팅 메시지
- logrotate — 로그 파일 로테이션 자동화
- /var/log 주요 파일 탐방 — 어떤 로그가 어디에 있나
- syslog와 rsyslog — 전통적 로깅 인프라
- systemd-logind — 세션과 전원 관리
- systemd-tmpfiles — 임시 파일과 디렉터리 자동 관리
- systemd-resolved와 systemd-networkd — DNS와 네트워크 설정
- systemd 저널 로테이션과 보존 정책
- journalctl로 로그 읽기 — systemd 저널 완전 활용
- systemd 타이머 vs cron — 스케줄 작업의 현대적 대안
- systemd 타겟 — 런레벨의 현대적 대체
- systemd 유닛 파일 — 서비스 정의의 모든 것
- systemctl 기본 — 서비스 관리의 핵심
- systemd 개요 — 현대 Linux의 init 시스템
- PAM 기초 — 플러그인 가능한 인증 모듈
- getent — 사용자·그룹 데이터베이스 조회
- id, whoami, w, who — 현재 사용자 확인 명령어
- su vs sudo — 사용자 전환의 두 가지 방법
- sudo & sudoers — 권한 위임과 보안 설정
- groupadd & usermod — 그룹 관리와 사용자 속성 변경
- passwd & shadow — 비밀번호 관리
- useradd & userdel — 사용자 생성과 삭제
- rsync over SSH — 원격 파일 동기화
- SSH 포트 포워딩 — -L, -R, -D 완전 정복
- 네트워크 네임스페이스 — 격리된 네트워크 스택
- /etc/hosts — 정적 호스트 매핑
- resolv.conf & systemd-resolved — DNS 설정
- NetworkManager — 네트워크 연결 관리
- firewalld & ufw — 방화벽 관리 도구
- nftables — iptables의 현대적 후계자
- iptables — 리눅스 방화벽 기초
- tcpdump — 패킷 캡처 기초
- curl·wget — HTTP 요청과 파일 다운로드
- dig·nslookup·host — DNS 질의 도구 완전 가이드
- netstat·ss — 소켓과 연결 상태 분석
- ping·traceroute — 네트워크 연결성 진단
- ip addr·link·route — 현대 리눅스 네트워크 설정
- ip vs ifconfig — 네트워크 인터페이스 도구 비교
- 소스에서 빌드하기 — ./configure·make·make install
- Snap·Flatpak — 배포판 독립 패키지 시스템
- pacman — Arch Linux 패키지 관리자 완전 가이드
- rpm — Red Hat 패키지의 저수준 관리
- yum / dnf — Red Hat 계열 패키지 관리자 완전 가이드
- dpkg 완전 이해 — .deb 패키지 저수준 관리
- apt search · show — 패키지 탐색과 정보 조회
- apt 기초 — 패키지 설치·제거·업데이트 완전 가이드
- namespaces 완전 개요 — 프로세스 격리의 원리
- cgroups 완전 개요 — 자원 격리의 뼈대
- zombie와 orphan 프로세스 완전 정복
- fork / exec / wait 완전 이해 — 프로세스 생성의 원리
- 프로세스 상태 완전 이해 — Running부터 Zombie까지
- pgrep과 pkill — 이름으로 프로세스 찾기와 종료
- nohup과 disown — 터미널 종료 후에도 프로세스 유지하기
- fg, bg, jobs — 포그라운드·백그라운드 작업 관리
- nice와 renice — 프로세스 CPU 우선순위 조정
- kill과 시그널 — 프로세스에 명령을 보내는 방법
- top과 htop — 실시간 프로세스 모니터링
- pstree — 프로세스 부모-자식 트리 한눈에 보기
- ps 완전 가이드 — aux와 -ef로 프로세스 목록 읽기
- 프로세스 해부학 — 리눅스 프로세스의 구조와 생명주기
- 불변 파일 — 시스템 파일을 침입자로부터 보호
- chattr · lsattr — 파일 속성으로 추가 보호
- ACL — getfacl·setfacl로 세밀한 권한 제어
- SUID · SGID · Sticky 비트 — 특수 권한 완전 정복
- umask — 파일 생성 기본 권한 제어
- chown · chgrp — 파일 소유자와 그룹 변경
- chmod — 숫자·심볼릭으로 권한 바꾸기
- 리눅스 파일 권한 — rwx 완전 이해
- ZFS · Btrfs — Copy-on-Write 파일시스템 완전 정복
- 소프트웨어 RAID — mdadm으로 고가용성 스토리지 구성하기
- LVM 기초 — 유연한 논리 볼륨 관리자 완전 정복
- swap — 리눅스 가상 메모리 스왑 완전 정복
- fsck — 파일시스템 검사와 손상 복구
- tune2fs — ext 파일시스템 슈퍼블록 조정과 resize2fs
- mkfs — 파티션에 파일시스템 포맷하기
- fdisk/parted — 파티션 생성과 테이블 관리
- lsblk/blkid — 블록 장치 구조와 UUID 조회
- df/du — 디스크 사용량 한눈에 파악하기
- /etc/fstab — 부팅 자동 마운트 설정 완전 정복
- mount/umount — 파일시스템을 디렉터리 트리에 연결하기
- 리눅스 파일 유형 7가지: - d l c b p s
- 하드 링크 vs 심볼릭 링크: 연결의 두 가지 방식
- inode 완전 해부: 파일 시스템의 심장
- read: 스크립트에서 사용자 입력 받기
- tee: 파이프라인을 분기하는 T자 이음새
- echo & printf: 표준 출력 제어하기
- alias: 나만의 명령어 단축키 만들기
- history & !bang: 셸 히스토리 완전 활용
- man · info · help: 리눅스 매뉴얼 완전 활용
- which · whereis · type: 명령어 위치 추적의 세 가지 방법
- locate & updatedb: 초고속 파일 위치 검색
- find -exec & xargs: 찾은 파일에 명령 실행하기
- find 기초: 파일 이름·크기·날짜로 검색하기
- touch & stat: 파일 생성과 메타데이터 조회
- mkdir & rmdir: 디렉터리 생성과 삭제
- cp·mv·rm: 파일 복사·이동·삭제 완전 정복
- less & more: 대용량 파일을 페이지 단위로 읽기
- cat·tac·head·tail: 파일 내용 보기 4총사
- 절대 경로 vs 상대 경로: Linux 파일 주소 완벽 이해
- 숨김 파일 완전 이해: 점(.)으로 시작하는 파일의 비밀
- 파일과 디렉터리의 차이: Linux가 구분하는 방법
- pwd, cd, ls: 파일시스템 탐색의 기본기
- Linux FHS: 디렉터리 구조 완전 정복
- Bash vs Zsh vs Fish: 어떤 셸을 써야 할까
- 셸과 터미널의 차이: 무엇이 명령어를 실행하는가
- Linux 철학: 모든 것은 파일이다
- Linux 커널과 배포판의 차이: 무엇이 커널이고 무엇이 배포판인가
- Linux 배포판 한눈에 보기: Ubuntu·RHEL·Arch의 차이
- Unix와 Linux의 역사: C언어, GNU, 그리고 Linus Torvalds
- Linux란 무엇인가: 커널부터 배포판까지 한눈에
Nexacro
맨 처음 ↓- [Nexacro N] 트러블슈팅: 팝업 차단 문제
- [Nexacro N] 트러블슈팅: 인코딩 문제
- [Nexacro N] 트러블슈팅: 타임존 문제
- [Nexacro N] 트러블슈팅: 메모리 누수
- [Nexacro N] 트러블슈팅: Grid가 렌더링되지 않을 때
- [Nexacro N] 트러블슈팅: Dataset이 비어 있을 때
- [Nexacro N] 트러블슈팅: 이중 트랜잭션
- [Nexacro N] 트러블슈팅: 폼이 표시되지 않을 때
- [Nexacro N] 코드 컨벤션
- [Nexacro N] 로깅 표준
- [Nexacro N] 에러 전략
- [Nexacro N] 화면 책임 설계
- [Nexacro N] 베이스 폼 아키텍처 설계
- [Nexacro N] MVP·MVC 아키텍처 적용
- [Nexacro N] Nexacro 프로토콜 PL
- [Nexacro N] SOAP과 REST 연동
- [Nexacro N] DB 연동 패턴
- [Nexacro N] Node.js 어댑터
- [Nexacro N] Java 어댑터 심화
- [Nexacro N] Spring Boot 연동
- [Nexacro N] 어댑터 개요
- [Nexacro N] IE에서 모던 브라우저로 전환
- [Nexacro N] 레거시 컴포넌트 교체 전략
- [Nexacro N] v24 주요 변경 사항 총정리
- [Nexacro N] Nexacro Platform에서 N으로 마이그레이션
- [Nexacro N] Nexacro 14에서 Platform으로 마이그레이션
- [Nexacro N] 핫픽스 배포 전략
- [Nexacro N] 캐시 관리 전략
- [Nexacro N] 환경별 설정 분리 전략
- [Nexacro N] 빌드 옵션과 배포 설정
- [Nexacro N] 회귀 테스트 도구와 자동화 전략
- [Nexacro N] 시나리오 테스트와 UI 자동화
- [Nexacro N] 스크립트 단위 테스트 전략
- [Nexacro N] 런타임 오류 디버깅 전략
- [Nexacro N] Studio 디버그 모드 활용
- [Nexacro N] 네트워크 트레이스 분석
- [Nexacro N] trace() 로깅 활용 가이드
- [Nexacro N] 폼 재사용 전략과 공통 컴포넌트
- [Nexacro N] 메모리 누수 패턴과 진단
- [Nexacro N] 이벤트 핸들러 정리와 메모리 관리
- [Nexacro N] 화면 렌더링(Paint) 최적화
- [Nexacro N] 대용량 데이터 처리 전략
- [Nexacro N] 성능 최적화 개요
- [Nexacro N] 스타일 파일 관리
- [Nexacro N] 동적 스타일 적용
- [Nexacro N] CSS 유사 속성
- [Nexacro N] 테마 시스템
- [Nexacro N] 언어 전환
- [Nexacro N] 컴포넌트 텍스트 매핑
- [Nexacro N] 다국어(i18n) 개요
- [Nexacro N] 데이터 암호화
- [Nexacro N] CSRF 방어
- [Nexacro N] XSS 방어
- [Nexacro N] 토큰 인증
- [Nexacro N] SSO 연동
- [Nexacro N] 권한 체크
- [Nexacro N] 세션 타임아웃 처리
- [Nexacro N] 세션과 로그인
- [Nexacro N] 대시보드 구성
- [Nexacro N] 외부 차트 연동
- [Nexacro N] Plot 컴포넌트
- [Nexacro N] 엑셀 이미지 삽입
- [Nexacro N] 엑셀 병합·서식
- [Nexacro N] 엑셀 템플릿 출력
- [Nexacro N] 엑셀 내보내기·가져오기
- [Nexacro N] 파일 서버 처리
- [Nexacro N] 파일 업로드 진행률
- [Nexacro N] 다중 파일 업로드
- [Nexacro N] 파일 업로드·다운로드
- [Nexacro N] 페이지 내비게이션
- [Nexacro N] Tab Frame 구성
- [Nexacro N] 다국어 메뉴 구성
- [Nexacro N] 권한 기반 메뉴
- [Nexacro N] 메뉴 컨트롤
- [Nexacro N] 런타임 폼 로드
- [Nexacro N] 동적 그리드 컬럼
- [Nexacro N] addChild / removeChild
- [Nexacro N] 동적 컴포넌트 생성
- [Nexacro N] 팝업 스택 관리
- [Nexacro N] 팝업 생명주기
- [Nexacro N] 모달과 모달리스 팝업
- [Nexacro N] 팝업 콜백 패턴
- [Nexacro N] 팝업 파라미터 전달과 수신
- [Nexacro N] 팝업 기초 — openPopup과 팝업 생명주기
- [Nexacro N] 공유 이벤트 버스 패턴
- [Nexacro N] 폼 템플릿 활용 — 빠른 업무 화면 생성
- [Nexacro N] BaseForm — 기본 폼 아키텍처
- [Nexacro N] 공통 confirm·alert 팝업 설계
- [Nexacro N] 공유 변수와 application 객체 활용
- [Nexacro N] 전역 함수(gfn) 설계와 활용
- [Nexacro N] 공통 라이브러리 include 방법
- [Nexacro N] 공통 라이브러리 설계 개요
- [Nexacro N] 유효성 검사 UX 패턴
- [Nexacro N] 유효성 검사 공통 함수 설계
- [Nexacro N] 그리드 유효성 검사
- [Nexacro N] 서버 유효성 검사 처리
- [Nexacro N] 범위 검사 구현
- [Nexacro N] 형식 검사 구현
- [Nexacro N] 필수값 검사 구현
- [Nexacro N] 유효성 검사 개요
- [Nexacro N] 트랜잭션 단위 설계
- [Nexacro N] 멀티 행 저장 패턴 완전 가이드
- [Nexacro N] fn_save() 저장 처리 완전 가이드
- [Nexacro N] fn_delete() 삭제 처리 패턴
- [Nexacro N] Dataset 변경 추적과 rowStatus 활용
- [Nexacro N] fn_new() 신규 행 추가 패턴
- [Nexacro N] fn_search() 표준 조회 함수 구현
- [Nexacro N] CRUD 패턴 설계와 표준 구조
- [Nexacro N] SSE(Server-Sent Events) 실시간 수신
- [Nexacro N] WebSocket으로 실시간 서버 연동
- [Nexacro N] 트랜잭션 캐시 비활성화 전략
- [Nexacro N] 파일 트랜잭션: fileupload()와 filedownload() 완전 가이드
- [Nexacro N] 트랜잭션 커스텀 HTTP 헤더 추가
- [Nexacro N] 복수 Dataset 동시 처리 — 효율적인 서버 통신 설계
- [Nexacro N] 트랜잭션 오류 처리 전략
- [Nexacro N] 동기 vs 비동기 트랜잭션 — 언제 무엇을 써야 하나
- [Nexacro N] 콜백(Callback) 패턴 완전 정리
- [Nexacro N] transaction() args 파라미터 완전 활용
- [Nexacro N] 입력·출력 Dataset 매핑 심화
- [Nexacro N] 서비스 URL 설정과 TypeDefinition 관리
- [Nexacro N] 트랜잭션(Transaction) 개요 — 서버 통신의 기본 단위
- [Nexacro N] 디버깅 완전 가이드 — Studio부터 런타임까지
- [Nexacro N] 스크립트 오류 처리 패턴
- [Nexacro N] 네이밍 컨벤션 완전 정리
- [Nexacro N] 스크립트 스타일 가이드
- [Nexacro N] 사용자 정의 이벤트(Custom Event) 만들기
- [Nexacro N] 이벤트 버블링과 전파 제어
- [Nexacro N] 이벤트 취소와 return 값 제어
- [Nexacro N] this 컨텍스트 이해와 활용
- [Nexacro N] 이벤트 객체(Event Object) 파헤치기
- [Nexacro N] 이벤트 등록 방법 — Studio vs 스크립트
- [Nexacro N] 이벤트와 스크립트 기초
- [Nexacro N] 마스터-디테일 패턴 구현
- [Nexacro N] 동적 바인딩 — 런타임에 Dataset 교체하기
- [Nexacro N] 바인딩 표현식 — 계산 컬럼과 포맷
- [Nexacro N] bindcolumn과 value 속성 완전 정복
- [Nexacro N] 바인딩 방향 — 단방향·양방향 제어
- [Nexacro N] 데이터바인딩 개념과 기초
- [Nexacro N] Dataset CSV 데이터 다루기
- [Nexacro N] Dataset JSON 데이터 다루기
- [Nexacro N] Dataset loadXml로 클라이언트 데이터 초기화하기
- [Nexacro N] Dataset 탐색 함수 완전 정복 — find·findRow·findRowExpr
- [Nexacro N] Dataset copyData·mergeData 완전 정복
- [Nexacro N] Dataset 그룹 집계 기능
- [Nexacro N] Dataset 정렬(setSortByField) 가이드
- [Nexacro N] Dataset 필터(setFilter) 완전 정복
- [Nexacro N] Dataset 행 순회 패턴
- [Nexacro N] Dataset 행 추가·수정·삭제
- [Nexacro N] Dataset savedOrg — 원본 데이터 보관
- [Nexacro N] Dataset rowType — 행 상태 추적
- [Nexacro N] Dataset 타입 완전 정리
- [Nexacro N] Dataset ConstColumn — 상수 컬럼 활용
- [Nexacro N] Dataset 개요 — 데이터의 심장
- [Nexacro N] Grid 트러블슈팅
- [Nexacro N] Grid 렌더링 최적화
- [Nexacro N] Grid 가상화(Virtual Scrolling)
- [Nexacro N] Grid 대용량 데이터 처리
- [Nexacro N] Grid 클립보드 복사·붙여넣기
- [Nexacro N] Grid 엑셀 단축키 설정
- [Nexacro N] Grid 셀 유효성 검사
- [Nexacro N] Grid 셀 이벤트 완전 정복
- [Nexacro N] Grid EditControl — 셀 편집 컨트롤 완전 정복
- [Nexacro N] Grid Row Actions — 행 단위 액션
- [Nexacro N] Grid Paging — 페이징 처리
- [Nexacro N] Grid Sort & Filter — 정렬과 필터
- [Nexacro N] Grid Grouping — 그룹핑 처리
- [Nexacro N] Grid Summary — 합계 행 구성
- [Nexacro N] Grid Fixed Columns — 고정 컬럼 설정
- [Nexacro N] Grid Cell Merge — 셀 병합 처리
- [Nexacro N] Grid Multi Header — 다중 헤더 구성
- [Nexacro N] Grid Styles — 그리드 스타일 완전 가이드
- [Nexacro N] Grid Binding — 그리드 데이터 바인딩 심화
- [Nexacro N] Grid Cell Types — 셀 타입 완전 가이드
- [Nexacro N] Grid Format Editor — 그리드 포맷 에디터 활용
- [Nexacro N] Grid — 그리드 컴포넌트 개요
- [Nexacro N] Menu · Navigation — 메뉴 네비게이션 구현
- [Nexacro N] Tree — 트리 컴포넌트 완전 정복
- [Nexacro N] TabControl — 탭 컨테이너 완전 정복
- [Nexacro N] Button — 버튼 컴포넌트 완전 정복
- [Nexacro N] Plot — 차트 컴포넌트 완전 정복
- [Nexacro N] ProgressBar — 진행 상태 시각화 컴포넌트
- [Nexacro N] ImageViewer · Picture — 이미지 표시 컴포넌트 완전 정복
- [Nexacro N] Static — 텍스트 레이블 컴포넌트의 모든 활용법
- [Nexacro N] Hidden — 화면에 보이지 않는 데이터 컨테이너
- [Nexacro N] Select / MultiSelect — 리스트 박스 선택 컴포넌트
- [Nexacro N] Combo — 드롭다운 목록의 구조와 데이터 바인딩
- [Nexacro N] Radio / CheckBox — 선택 컴포넌트 활용 가이드
- [Nexacro N] Spin — 숫자 증감 컴포넌트 완전 정복
- [Nexacro N] Calendar — 날짜 선택 컴포넌트 활용 가이드
- [Nexacro N] MaskEdit — 서식 있는 입력 필드의 모든 것
- [Nexacro N] Edit / Textarea — 텍스트 입력 컴포넌트 완전 분석
- [Nexacro N] Div 그루핑 — 복잡한 화면을 논리 단위로 묶는 방법
- [Nexacro N] 다중 해상도 지원 — DPI·해상도별 화면 최적화 전략
- [Nexacro N] 반응형 레이아웃 — 화면 크기 변화에 유연하게 대응하기
- [Nexacro N] Anchor·Margin·Padding — 컴포넌트 위치와 여백 완전 정복
- [Nexacro N] Container vs Form — 컴포넌트 배치의 두 가지 방식
- [Nexacro N] 레이아웃과 스타일 기초 — Nexacro N의 화면 배치 원리
- [Nexacro N] Form Include — 화면 조각을 재사용하는 include 기법
- [Nexacro N] Form 상속 — 공통 기능을 BaseForm으로 물려받기
- [Nexacro N] Form 생명주기 — onCreate에서 onDestroy까지
- [Nexacro N] Application·Frame·Form의 관계 — 화면 계층 구조 심층 분석
- [Nexacro N] Form 타입 완전 정복 — MainFrame부터 PopupForm까지
- [Nexacro N] 빌드와 배포 — Nexacro Studio로 빌드하고 웹 서버에 올리기
- [Nexacro N] TypeDef.xml과 Service.xml — 컴포넌트 등록과 서비스 URL 관리
- [Nexacro N] Environment.xml 완전 해부 — 서버 연결·프로토콜·인코딩 설정
- [Nexacro N] 프로젝트 구조 완전 해부 — 파일·폴더 역할 총정리
- [Nexacro N] Nexacro Studio N 단축키 완전 정복
- [Nexacro N] Nexacro Studio N UI 완전 투어
- [Nexacro N] Nexacro Studio N 설치와 환경 구성
- [Nexacro N] 라이선스 체계와 배포 방식 완전 해설
- [Nexacro N] HTML5 런타임 동작 원리
- [Nexacro N] Nexacro N, 언제 도입해야 하는가
- [Nexacro N] Nexacro N vs Platform — 실질적 차이점
- [Nexacro N] 아키텍처 개요 — 브라우저·런타임·서버
- [Nexacro N] Nexacro 14 → Platform → N · V24 진화
- [Nexacro N] Nexacro란 무엇인가 — RIA 시대부터 N까지
Docker
맨 처음 ↓- CRI — 쿠버네티스 컨테이너 런타임 인터페이스
- OCI 스펙 — 컨테이너 표준화의 기반
- Skopeo — pull 없이 이미지 복사·검사하는 도구
- Buildah — 데몬 없이 컨테이너 이미지 빌드
- nerdctl — containerd용 Docker 호환 CLI
- Podman vs Docker — 데몬리스 컨테이너 런타임 비교
- runc & containerd — Docker 런타임 스택 해부
- OverlayFS — 컨테이너 파일시스템의 비밀
- Linux Namespaces & cgroups — Docker 격리의 진짜 원리
- Docker BuildKit 심화 — 내부 구조와 고급 기능
- Docker 컨테이너 시간대(Timezone) 불일치 해결
- Docker 빌드 캐시 실패 트러블슈팅
- Docker OOM Kill 해결 — 컨테이너 메모리 부족
- Docker 볼륨 마운트 권한 문제 해결
- Docker Port Already in Use 에러 해결
- Docker 네트워크 서브넷 충돌 해결
- Docker Hub 이미지 Pull Rate Limit 해결
- Docker No space left on device 에러 해결
- Docker Permission Denied 에러 완전 해결 가이드
- Docker 데몬 연결 오류 해결하기
- .dockerignore — 빌드 컨텍스트를 최소화하는 방법
- VS Code Dev Containers로 팀 개발 환경 표준화하기
- Docker로 개발 환경 구성하기
- 컨테이너 안에서 테스트 실행하기
- docker/build-push-action 완전 정복
- docker buildx bake — 복잡한 빌드를 선언형으로
- GitHub Actions로 Docker 이미지 빌드 자동화하기
- Docker CI 기초 — 컨테이너로 빌드 파이프라인 구성하기
- 컨테이너 DNS 문제 진단과 수정
- 컨테이너 네트워크 연결 문제 디버깅
- 컨테이너 권한 오류 디버깅: Permission denied 완벽 해결
- tcpdump로 컨테이너 네트워크 패킷 분석하기
- strace로 컨테이너 시스템콜 추적하기
- 컨테이너에 셸로 접속하기: exec, attach, nsenter
- 실패한 컨테이너 원인 분석하기
- 실행 중인 컨테이너 디버깅 전략
- Cosign으로 Docker 이미지 서명하기
- GitHub Container Registry: ghcr.io 완전 활용법
- GCP Artifact Registry: Docker 이미지 저장과 CI/CD 통합
- AWS ECR 완전 정복: 인증·수명 주기·스캔
- Harbor로 엔터프라이즈 레지스트리 구축하기
- 프라이빗 레지스트리 구축과 운영
- Docker Hub 완전 정복: pull, push, 태그, Rate Limit
- Docker 레지스트리 완전 정복: 개념과 구조
- Docker 이미지에서 시크릿 유출 방지하기
- Docker 레이어 캐싱 전략과 실전 팁
- BuildKit 캐시 마운트: RUN --mount=type=cache 완전 정복
- Docker Slim과 이미지 최적화 도구 활용법
- Scratch 이미지: 절대 최소 컨테이너 만들기
- Alpine 이미지 함정: musl libc와 패키지 누락 문제
- Distroless 이미지: 셸 없는 경량 보안 컨테이너
- Docker 이미지 크기 줄이기: 경량 이미지 최적화 전략
- Docker Rootless Mode: daemon 자체를 비루트로 실행
- Docker AppArmor/SELinux: 강제 접근 제어 적용
- Docker seccomp 프로파일: 허용 syscall 화이트리스트
- Docker cap-drop/add: Linux Capability 최소화
- Docker 읽기 전용 루트 파일 시스템: --read-only 완전 활용
- Docker 이미지 취약점 스캔: Trivy와 Docker Scout
- Docker Content Trust: 이미지 서명으로 공급망 공격 방지
- Docker Secrets: 시크릿 안전하게 관리하기
- Docker 비루트 사용자: 컨테이너 권한 최소화
- Docker 보안 개요: 컨테이너 보안의 핵심 원칙
- Docker 디스크 정리: 공간 확보 완전 가이드
- docker system prune: 사용하지 않는 리소스 일괄 정리
- Docker 스토리지 드라이버: overlay2 완전 정복
- Docker 로깅 드라이버: 로그 수집·전달 완전 정복
- Docker 좀비 프로세스: 발생 원인과 방지 전략
- Docker init 프로세스: tini로 좀비·시그널 문제 해결
- Docker 시그널 전파: PID 1과 시그널 처리 완전 정복
- Docker 컨테이너 우아한 종료: SIGTERM과 stop 완전 정복
- Docker ulimit: 컨테이너 리소스 한도 미세 조정
- Docker 리소스 제한: CPU·메모리 완전 정복
- Docker 재시작 정책: restart 완전 정복
- Docker Compose logs/ps: 서비스 상태 조회와 로그 분석
- Docker Compose up/down: 서비스 생명주기 완전 정복
- Docker Compose watch: 소스 변경 자동 감지 핫 리로드
- Docker Compose override: 환경별 설정 재정의 패턴
- Docker Compose extends와 merge: 설정 재사용과 공통 베이스
- Docker Compose profiles: 환경별 서비스 선택 실행
- Docker Compose healthcheck: 서비스 상태 검사 완전 정복
- Docker Compose depends_on: 서비스 의존성과 시작 순서 제어
- Docker Compose environment: 환경 변수 완전 정복
- Docker Compose networks: 멀티 네트워크로 서비스 격리
- Docker Compose volumes: named volume, bind mount, tmpfs
- Docker Compose build vs image: 언제 무엇을 쓰나
- Docker Compose services 완전 정복
- Docker Compose YAML 기초 문법
- Docker Compose 개요: 멀티 컨테이너 앱 관리
- Docker 네트워크 트러블슈팅: 연결 안 될 때 진단 가이드
- Docker 네트워크 격리: 컨테이너 간 통신 제어
- Docker -p (publish)와 EXPOSE의 차이: 포트 공개의 진실
- Docker 포트 매핑 완전 정복: -p와 --expose
- Docker 네트워크 DNS: 컨테이너 이름 해석 원리
- docker network inspect: 네트워크 상태 분석
- docker network create: 사용자 정의 네트워크 만들기
- Docker macvlan 네트워크: 물리 네트워크 직접 연결
- Docker overlay 네트워크: 멀티호스트 컨테이너 통신
- Docker none 네트워크: 완전한 네트워크 격리
- Docker host 네트워크: 격리 없는 최고 성능
- Docker bridge 네트워크 완전 분석: veth, docker0, NAT
- Docker 네트워크 완전 정복: 드라이버 종류와 동작 원리
- Docker 볼륨 함정과 해결책: 자주 만나는 문제들
- Docker 볼륨 권한 관리: 컨테이너 내 파일 접근 제어
- Docker 볼륨 백업과 복원: 데이터 보호 전략
- Docker 볼륨 드라이버: 외부 스토리지 연결하기
- tmpfs 마운트: 메모리 기반 임시 파일 시스템
- Bind Mount 완전 정복: 호스트 디렉터리를 컨테이너에 마운트
- Anonymous Volume 이해하기: 컨테이너와 함께 사는 볼륨
- Named Volume 완전 정복: 이름 있는 볼륨 생성·관리
- Docker 볼륨 종류: Named, Anonymous, Bind Mount, tmpfs 비교
- Docker 볼륨 기초: 데이터를 컨테이너 밖에서 관리하기
- Dockerfile 안티 패턴 총정리
- Dockerfile 모범 사례 총정리
- buildx 멀티 아키텍처 빌드 완전 정복
- 빌드 ARG 고급 활용
- BuildKit 완전 정복
- 멀티 스테이지 빌드 완전 정복
- Dockerfile 레이어 캐시 전략
- Shell 폼 vs Exec 폼 완전 정복
- ONBUILD 인스트럭션 완전 정복
- HEALTHCHECK 인스트럭션 완전 정복
- USER 인스트럭션 완전 정복
- VOLUME 인스트럭션 완전 정복
- EXPOSE 인스트럭션 완전 정복
- CMD vs ENTRYPOINT: 컨테이너 시작 명령
- ENV vs ARG: 환경변수와 빌드 인수
- WORKDIR 인스트럭션 완전 정복
- COPY vs ADD: 무엇을 써야 하는가
- RUN 인스트럭션 완전 정복
- FROM 인스트럭션 완전 정복
- Dockerfile 해부학 — 구조와 기본 문법
- 베이스 이미지 선택 전략
- Docker 이미지 네이밍과 태깅 전략
- 멀티 아키텍처 이미지와 docker buildx
- Docker 이미지 Digest — 불변 참조의 핵심
- Docker 이미지 레이어 구조 이해하기
- docker export/import — 컨테이너 스냅샷 활용
- docker image save/load — 이미지 파일 저장·불러오기
- docker image prune — 불필요한 이미지 정리
- docker image history — 이미지 레이어 이력 조회
- docker rmi — 이미지 삭제
- docker image ls — 이미지 목록 조회
- docker image tag — 이미지 태그 관리
- docker image push — 이미지 올리기
- docker image pull — 이미지 내려받기
- Docker 이미지의 본질 — 레이어와 유니온 마운트
- docker rename — 컨테이너 이름 변경
- docker pause / unpause — 컨테이너 일시 정지
- docker cp — 컨테이너와 호스트 간 파일 복사
- docker port — 포트 매핑 확인
- docker events — 실시간 이벤트 스트림 모니터링
- docker top — 컨테이너 내부 프로세스 확인
- docker stats — 실시간 리소스 모니터링
- docker inspect — 컨테이너·이미지 상세 정보 조회
- docker logs — 컨테이너 로그 조회 완전 정복
- docker attach vs exec — 차이점과 올바른 활용법
- docker exec — 실행 중인 컨테이너에 명령 실행
- docker rm — 컨테이너 삭제 완전 정복
- 컨테이너 중지·시작·재시작 — stop, start, restart 명령
- docker ps — 실행 중인 컨테이너 조회 완전 정복
- docker run 기초 — 컨테이너 실행의 시작
- Docker Context — 여러 Docker 환경을 손쉽게 전환하기
- Docker Rootless 모드 — root 없이 안전하게 실행하기
- Docker Desktop vs Docker Engine — 언제 무엇을 쓸까?
- Docker 설치 완전 가이드 — Linux · macOS · Windows
- Docker CLI 완전 가이드 — 명령어 체계 총정리
- Docker 엔진과 데몬 — dockerd 내부 동작
- Docker 아키텍처 완전 이해 — 클라이언트·데몬·레지스트리
- Docker의 역사 — chroot에서 OCI 표준까지
- 컨테이너 vs 가상 머신 — 무엇을 선택할까?
- 컨테이너란 무엇인가?
TypeScript
맨 처음 ↓- 이펙티브 타입스크립트 — 실무에서 바로 쓰는 핵심 팁
- 타입 설계 베스트 프랙티스
- 자주 만나는 에러 메시지 읽기
- 대규모 코드베이스 전략
- 타입 체크 성능 끌어올리기
- any를 체계적으로 제거하기
- 점진적으로 strict 강화하기
- JSDoc으로 타입 작성하기
- allowJs와 checkJs
- TypeScript 마이그레이션 전략
- 타입과 시맨틱 버저닝
- 타입을 포함한 라이브러리 배포하기
- .d.ts 번들링
- SWC와 esbuild의 타입 처리
- 타입을 테스트하기: expectTypeOf와 tsd
- Vitest와 Jest 타이핑
- AbortController 타이핑
- 비동기 이터레이터 타이핑
- Promise 깊이 타이핑하기
- 제네릭 컴포넌트 만들기
- React 이벤트 핸들러 타이핑
- React Context 타이핑
- ref와 forwardRef 타이핑
- React Hooks 타이핑 — useState부터 useReducer까지
- React Props와 children 타이핑
- fetch 타이핑 — Response와 unknown 기반 파싱
- Express 타이핑 — Request 제네릭과 미들웨어
- HTTP 핸들러 타이핑 — 요청·응답에 타입 입히기
- fs / path 타이핑 — 파일 시스템 API 안전하게
- Node.js 코어 타이핑 — @types/node와 내장 모듈
- 환경 변수 타이핑 — process.env 안전하게 다루기
- 의존성 주입 타이핑 — 토큰과 컨테이너 설계
- 상태 머신 타이핑 — 불가능한 상태를 제거하기
- 빌더 패턴 타이핑 — 타입으로 단계 강제하기
- Result / Either 타입 — 예외 없는 에러 처리
- JSON.parse 타이핑 — unknown 기반 안전한 파싱
- JSON 타이핑 — JSON 값을 안전하게 표현하기
- Phantom 타입 — 타입으로만 상태를 추적하기
- Opaque 타입 — 구조적 타이핑에 명목성 부여하기
- 리터럴 유니온 자동완성 — string & {} 패턴
- UnionToIntersection — 유니온을 인터섹션으로 변환하기
- type-challenges 입문 — 타입 레벨 프로그래밍 연습
- TypeScript 빌드 성능 최적화 — 컴파일 속도 끌어올리기
- TypeScript 에러 핸들링 — unknown catch와 타입 안전한 예외 처리
- async/await와 Promise 타이핑 — 비동기 코드의 타입
- React 타이핑 시작 — 컴포넌트와 props의 타입
- typescript-eslint — 타입 인식 린팅 설정하기
- 프로젝트 레퍼런스 — 모노레포를 위한 빌드 분할
- composite와 incremental — 증분 빌드의 기초
- isolatedModules — 파일 단위 트랜스파일을 위한 제약
- lib·target·module — 컴파일 타깃을 결정하는 3대 옵션
- paths와 baseUrl — 경로 별칭으로 import 정리하기
- strict 모드 플래그 — 엄격함을 구성하는 옵션들
- 전역 보강 — Window와 전역 스코프 확장하기
- 모듈 보강 — 남의 라이브러리 타입을 확장하기
- 선언 병합 — 같은 이름의 선언이 만나면
- 앰비언트 모듈 — 타입 없는 모듈에 타입 입히기
- 앰비언트 선언 — 컴파일러에게 존재를 알리기
- DefinitelyTyped와 @types — 커뮤니티 타입 생태계
- 선언 파일(.d.ts) — 타입 정보의 배포 형식
- verbatimModuleSyntax — 모듈 구문을 쓴 그대로
- 타입 전용 import/export — import type 완전 정복
- Node16/NodeNext 모듈 해석 — ESM 시대의 규칙
- 모듈 해석 — TypeScript가 import를 찾는 방법
- satisfies 연산자 — 타입 검증과 추론 보존을 동시에
- Deep Readonly 패턴 완전 정복
- ThisType과 OmitThisParameter 완전 정복
- InstanceType과 ConstructorParameters 완전 정복
- NonNullable 유틸리티 타입 완전 정복
- Awaited 유틸리티 타입 완전 정복
- ReturnType과 Parameters로 함수 타입 분해하기
- Extract와 Exclude로 유니언 조각내기
- Record 타입 완전 정복
- Pick과 Omit으로 타입 조각내기
- Partial · Required · Readonly 완전 정복
- 유틸리티 타입 총정리 — Partial에서 Awaited까지
- 튜플 타입 조작 — 분해·재조합·변환 패턴
- 타입 레벨 산술 — 튜플 길이로 숫자 연산 구현
- 재귀 조건부 타입 — 타입 레벨 패턴 매칭의 극한
- 재귀 타입 — 자기 자신을 참조하는 타입 구조
- 인트린직 문자열 타입 — Uppercase·Lowercase·Capitalize·Uncapitalize
- 매핑된 타입 수정자 — +/-와 as 키 재매핑
- 분산성 — 공변·반변·불변과 in/out 어노테이션
- NoInfer 유틸리티 — 제네릭 추론 사이트 제어
- 제네릭 기본값 — 타입 파라미터의 선택적 지정
- 제네릭 클래스 — 타입 파라미터를 가진 클래스
- 제네릭 함수 — 타입 안전한 재사용
- 정적 멤버 — 클래스 레벨의 공유 상태
- 게터와 세터 — 프로퍼티 접근 제어
- 파라미터 프로퍼티 — 생성자 단축 선언
- 클래스 상속 — extends와 super 완전 정리
- 추상 클래스 — 설계도와 구현 분리
- ECMAScript 비공개 필드 — # 기반 런타임 캡슐화
- 접근 제한자 — public, private, protected 완전 정리
- TypeScript 클래스 기초 — 객체지향의 출발점
- 초과 프로퍼티 검사 — 객체 리터럴의 엄격한 검사
- 명목적 타입과 브랜드 타입 — 의미 있는 타입 구분
- 구조적 타이핑 — TypeScript가 타입을 비교하는 방법
- 인덱스 접근 타입 — T[K]로 타입 추출
- keyof와 typeof — 타입에서 키를 추출하다
- readonly와 const 단언 — 불변 타입 설계
- 인덱스 시그니처 — 동적 키 타입 처리
- interface extends — 계층적 타입 설계
- 단언 함수 — asserts 키워드와 불변식 검사
- 완전성 검사 — switch와 never로 빠진 케이스 잡기
- 제어 흐름 분석 — TypeScript가 타입을 추적하는 방식
- in 연산자 타입 가드 — 프로퍼티 존재 여부로 타입 구분하기
- typeof와 instanceof 타입 가드 — 원시 타입과 클래스 인스턴스 구분
- 타입 좁히기(Narrowing) 기초 — 유니언 타입을 안전하게 다루는 방법
- this 매개변수 — TypeScript에서 this 타입을 명시하고 안전하게 쓰는 법
- 나머지 매개변수와 스프레드 — 가변 인수를 타입 안전하게 처리하기
- 선택적 매개변수와 기본값 — 유연한 함수 시그니처 설계
- 함수 오버로드 — 여러 시그니처로 정밀한 타입 표현
- 함수 타입 — TypeScript에서 함수를 타입으로 표현하는 방법
- TypeScript 완전 정복: 타입 단언(Type Assertion) 완전 이해
- 타입 어노테이션 — 언제 명시하고 언제 생략할까
- 타입 추론 완전 정리 — TypeScript가 타입을 결정하는 방식
- 리터럴 타입 — 정확한 값으로 타입 좁히기
- const enum — 컴파일 타임 인라인과 트레이드오프
- 열거형 완전 정리 — 숫자·문자열·이종 enum 사용 가이드
- 객체 타입 완전 정리 — 프로퍼티·옵셔널·인덱스 시그니처
- 가변 인자 튜플 — 스프레드와 추론으로 복잡한 타입 다루기
- 튜플 타입 — 고정 길이 이종 배열의 완전 정복
- 읽기 전용 배열 — ReadonlyArray와 readonly 수식어 완전 정리
- 배열 타입 완전 정리 — T[]와 Array<T> 문법부터 실전까지
- 타입 공간과 값 공간 — TypeScript의 두 세계
- TypeScript 에디터 환경 최적화 — VS Code 완전 설정
- TypeScript 특수 타입: any, unknown, never, void 완전 정복
- TypeScript 원시 타입 완전 정복: string, number, boolean 외 4종
- 첫 번째 TypeScript 프로그램: Hello World부터 타입 추론까지
- TypeScript Playground: 설치 없이 브라우저에서 실험하기
- tsc 컴파일러 완전 이해: 파이프라인과 핵심 옵션
- TypeScript 개발 환경 설치: Node.js부터 tsconfig까지
- TypeScript vs JavaScript: 코드로 보는 결정적 차이
- 왜 TypeScript인가? 현업에서의 실제 가치
- TypeScript 점진적 도입 — JS 프로젝트에서 TS로
- tsconfig 완전 정복 — 컴파일러 옵션 가이드
- 데코레이터 — 클래스와 멤버에 메타데이터 주입
- 모듈과 네임스페이스 — TypeScript 코드 구조화
- 판별 유니언 — 타입 안전한 상태 모델링
- 타입 가드 — 런타임 타입 좁히기 기법
- unknown · never · any — 타입 계층의 끝점들
- infer 키워드 — 조건부 타입 내 타입 추론
- 템플릿 리터럴 타입 — 문자열 타입 조합과 추론
- 매핑된 타입 — 기존 타입을 순회해 새 타입 만들기
- 조건부 타입 — 타입 수준의 분기 처리
- 제네릭 제약 — extends와 keyof
- 제네릭 기초 — 재사용 가능한 타입 추상화
- interface vs type — 차이와 선택 기준
- 유니언·인터섹션·리터럴 타입
- TypeScript 기본 타입 완전 정복
- TypeScript 핵심 · 왜 타입이 필요한가
Spring
맨 처음 ↓- Spring 점진적 현대화: 레거시에서 최신 Spring까지
- Spring Boot 2 → 3 마이그레이션 실전 가이드
- Spring 4 · 5 · 6 핵심 변경사항 총정리
- XML 설정에서 Java Config로: Spring 레거시 현대화 완전 가이드
- Spring AI 입문: ChatClient, RAG, 도구 호출까지
- Virtual Threads로 Spring MVC 성능 극대화하기
- GraalVM 네이티브 이미지: Spring AOT 컴파일 완전 가이드
- Java EE에서 Jakarta EE로: Spring Boot 3 마이그레이션 완전 가이드
- 함수형 엔드포인트: RouterFunction과 HandlerFunction
- R2DBC: 리액티브 관계형 DB 접근
- WebClient: 비동기 HTTP 클라이언트 완전 가이드
- Spring MVC vs WebFlux: 언제 무엇을 선택해야 하는가
- Reactor Mono·Flux 완전 정복: 오퍼레이터와 실전 패턴
- Spring WebFlux와 리액티브 프로그래밍 개념
- 분산 트랜잭션과 Saga 패턴: Choreography vs Orchestration
- Spring Cloud OpenFeign: 선언형 HTTP 클라이언트 완전 정복
- Spring Cloud Resilience4j: 장애 격리와 Circuit Breaker
- Spring Cloud Config Server: 중앙화된 설정 관리
- Spring Cloud Gateway: API 진입점 완전 정복
- Spring Cloud 서비스 디스커버리: Eureka 완전 정복
- Spring Cloud: 모놀리스에서 마이크로서비스로 — 언제, 어떻게 전환할까
- Spring Boot 시크릿 관리: 환경변수부터 AWS Secrets Manager와 Vault까지
- Spring Boot CI/CD 파이프라인: GitHub Actions부터 ECS 배포까지
- Spring Boot 애플리케이션 도커라이징: 레이어드 JAR와 멀티스테이지 빌드
- Spring Boot 멀티 모듈 프로젝트 — 구조 설계와 빌드 전략
- Spring Boot JAR vs WAR — 패키징 방식과 배포 전략 선택 가이드
- Spring Boot Graceful Shutdown — 안전한 서버 종료 전략
- Spring Boot 분산 추적 — Micrometer Tracing + Zipkin 실전 적용
- Micrometer + Prometheus — Spring Boot 메트릭 수집과 시각화
- Spring Boot Actuator — 커스텀 HealthIndicator 구현
- Spring Boot Actuator — 운영 모니터링 엔드포인트 완전 정복
- Spring 테스트 — 픽스처 격리 전략 완전 정복
- Spring 테스트 — Testcontainers로 실제 DB 테스트 완전 정복
- Spring 테스트 — MockMvc 심화 완전 정복
- Spring 테스트 — @SpringBootTest 통합 테스트 완전 정복
- Spring 테스트 슬라이스 — @WebMvcTest·@DataJpaTest·@JsonTest 완전 정복
- Spring 테스트 — Mockito 완전 정복
- Spring 테스트 — JUnit 5 & AssertJ 완전 정복
- 이벤트 기반 아키텍처 — Spring으로 구현하는 EDA 패턴
- Spring RabbitMQ — AMQP 메시지 발행·소비·오류 처리
- Spring Kafka 기초 — KafkaTemplate 발행과 @KafkaListener 소비
- @TransactionalEventListener — 트랜잭션 완료 후 이벤트 처리
- Spring ApplicationEvent — 이벤트 기반 느슨한 결합 구현
- Spring @Async 예외 처리 완전 정복 — void·Future·CompletableFuture 전략
- Spring 스케줄링 — @Scheduled와 Cron 표현식 완전 정복
- Spring 비동기 스레드풀 — @Async와 ThreadPoolTaskExecutor 완전 정복
- Spring HTTP 캐시 헤더 — Cache-Control과 ETag 완전 정복
- Spring Cache — Caffeine과 Redis 공급자 완전 정복
- Spring Cache 추상화 — @Cacheable · @CacheEvict 완전 정복
- Spring Security Remember-Me와 세션 관리
- Spring Security 리소스 서버와 인가 서버 구현
- Spring Security JWT 인증 구현
- Spring Security OAuth2 · OIDC 개념과 소셜 로그인 구현
- Spring Security 메서드 보안 — @PreAuthorize · @PostAuthorize 완전 정리
- Spring Security CSRF · CORS · CSP 완전 정리
- Spring Security 폼 로그인 구현 — formLogin() 완벽 정리
- UserDetailsService와 PasswordEncoder — 사용자 인증 구현
- Spring Security 인증과 인가 — Authentication vs Authorization
- Spring Security 아키텍처 — 필터 체인의 구조와 동작
- API 응답 봉투 패턴 — 일관된 응답 구조 설계
- Custom Validator — 커스텀 제약 어노테이션 만들기
- Validation Groups — 상황별 유효성 검증 분리
- MapStruct — 타입 안전한 객체 매핑 자동화
- DTO와 Entity 패턴 — 계층 간 데이터 분리 설계
- Jackson 심층 분석 — JSON 직렬화·역직렬화 완전 정복
- Spring REST Docs — 테스트 기반 API 문서 자동화
- OpenAPI 3.0 & Swagger UI로 REST API 문서화
- REST API 오류 응답 표준화 — RFC 7807 Problem Details
- REST API 버전 관리 — URI·헤더·Content-Type 전략 비교
- Spring REST API 페이징·필터·정렬 — Pageable과 Page 완전 가이드
- REST API HTTP 상태 코드 — 언제 무엇을 반환해야 하는가
- REST API 설계 원칙 — URI·메서드·표현의 일관성
- Spring Boot 트랜잭션 베스트 프랙티스 — @Transactional 실전 가이드
- Spring Boot 쿼리 로깅 — SQL·파라미터·성능 측정
- Spring Boot H2 콘솔 — 인메모리 DB로 빠른 개발 환경 구성
- Spring Boot Flyway & Liquibase — DB 마이그레이션 자동화
- Spring Boot 멀티 DataSource — 읽기/쓰기 분리부터 AbstractRoutingDataSource까지
- Spring Boot DataSource Auto-configuration 파헤치기
- 커스텀 Spring Boot Starter & Auto-configuration 만들기
- Spring Boot @Conditional — 조건부 Bean 등록 완전 정복
- Spring Boot @ConfigurationProperties 완전 정복
- Spring Boot DevTools & LiveReload로 개발 생산성 높이기
- Spring Boot 로깅 완전 정복: SLF4J와 Logback
- Spring Boot 내장 서버: Tomcat을 JAR 안에 품는 방법
- Spring Boot Starter 구조 완전 정복 — 내부 원리와 커스텀 Starter 만들기
- Spring Boot Auto-Configuration 동작 원리 완전 정복
- Spring Boot Profiles 완전 정복 — 환경별 설정 분리와 @Profile 활용
- Spring Boot 설정 외부화 완전 정복 — application.properties와 application.yml
- @SpringBootApplication 완전 정복 — 세 애노테이션의 합성과 동작 원리
- Spring Initializr 완전 정복 — 프로젝트 생성부터 첫 실행까지
- Spring Boot 4가지 핵심 특징 완전 정복 — Auto-Configuration · Embedded Server · Starter · Actuator
- Spring Data JPA Auditing 완전 정복 — 생성·수정 시각과 작성자 자동 기록
- Spring Data JPA Pageable·Sort 완전 정복 — 페이징과 정렬
- QueryDSL 완전 정복 — 타입 세이프 JPA 쿼리 빌더
- JPQL과 Native Query 완전 정복 — JPA 쿼리 언어 심층 가이드
- Spring Data JPA Repository 완전 정복 — JpaRepository부터 커스텀 쿼리까지
- JPA 상속 매핑 전략 완전 정복 — SINGLE_TABLE · JOINED · TABLE_PER_CLASS
- JPA Cascade와 orphanRemoval 완전 정복
- JPA N+1 문제 완전 정복 — 원인과 해결 전략
- JPA 페치 전략 완전 정복 — EAGER vs LAZY
- Spring JPA 연관 관계 매핑 완전 정복
- Spring JPA 1차 캐시와 변경 감지(Dirty Checking) 완전 정복
- Spring JPA 엔티티 생명주기 완전 정복
- Spring JPA EntityManager와 영속성 컨텍스트 완전 정복
- Spring JPA와 ORM 개념 정복: 패러다임 불일치와 JPA가 해결하는 방법
- Spring 선언적 vs 프로그래밍 방식 트랜잭션: @Transactional과 TransactionTemplate 완전 비교
- Spring 트랜잭션 격리 수준(Isolation) 완전 정복: Dirty Read부터 Serializable까지
- Spring 트랜잭션 전파(Propagation) 완전 정복: REQUIRED부터 NESTED까지
- Spring @Transactional 함정 완전 정복: 자기 호출·롤백 규칙·체크 예외
- Spring PlatformTransactionManager 완전 정복: 트랜잭션 추상화와 동기화
- Spring HikariCP 커넥션 풀 완전 정복: 원리·설정·모니터링
- Spring JdbcTemplate 완전 정복: 반복 코드 제거와 안전한 DB 접근
- Spring MVC 비동기 컨트롤러 완전 정복: Callable·DeferredResult·SseEmitter
- Spring CORS 설정 완전 정복: @CrossOrigin부터 Security 연동까지
- Spring Boot 파일 업로드·다운로드 완전 정복: MultipartFile부터 스트리밍까지
- Spring 인터셉터 vs 서블릿 필터: 차이점과 실전 활용 가이드
- Spring 예외 처리 완전 정복: @ExceptionHandler, @ControllerAdvice, RFC 7807
- Spring Validation: @Valid, @Validated, Bean Validation 완전 정복
- Spring @RestController 완전 정복: @Controller와 차이, ResponseEntity 활용법
- Spring HttpMessageConverter: JSON·XML 자동 변환의 핵심 원리
- Spring MVC 정적 리소스 처리: CSS·JS·이미지를 효율적으로 서빙하는 법
- Spring MVC Model과 ViewResolver: 데이터를 뷰에 전달하는 방법
- Spring MVC 파라미터 바인딩 완전 정복: @PathVariable부터 @ModelAttribute까지
- RESTful URL 매핑 전략: 자원·행위·계층을 URL에 담는 법
- @Controller와 @RequestMapping 완전 정복: URL 매핑 전략 총정리
- HandlerMapping과 HandlerAdapter 심화: 요청이 컨트롤러를 찾는 방법
- DispatcherServlet 완전 분석: Spring MVC 요청 처리 흐름의 시작
- Servlet · Filter · Listener 완전 정복: 웹 컨테이너 3요소의 역할과 실전 활용
- Spring AOP 실전 활용 사례: 로깅·트랜잭션·캐싱·보안을 AOP로 분리하기
- Spring AOP Pointcut 표현식 심화: execution·within·@annotation 완전 정복
- Spring AOP @Aspect 실전: Logging·성능·보안 Aspect 작성하기
- Spring AOP 프록시: JDK 동적 프록시 vs CGLIB 완전 정리
- Spring AOP 용어: Aspect, Advice, JoinPoint, Pointcut 완전 정리
- Spring AOP 개념: 횡단 관심사를 분리하는 방법
- Spring Property 외부화: @Value부터 Environment까지
- BeanPostProcessor: Spring 확장 포인트의 핵심
- Spring Bean 생명주기: 초기화부터 소멸까지 완전 분석
- Spring Bean Scope: 싱글톤부터 Request·Session까지
- @Autowired와 @Qualifier: 빈 선택 전략 완전 정리
- Spring DI 세 가지 방식: 생성자·세터·필드 주입 완전 비교
- 컴포넌트 스캔 — @ComponentScan과 스테레오타입 어노테이션
- 자바로 빈 설정하기 — @Configuration과 @Bean
- XML로 빈 설정하기 — <bean> 태그 완전 정복
- IoC 컨테이너 — BeanFactory와 ApplicationContext
- 의존성 관리 — scope, transitive, BOM
- Gradle 기초 — build.gradle과 태스크
- Maven 기초 — pom.xml과 라이프사이클
- JDK·IDE·빌드도구 한눈에 — 스프링 개발 환경 구축
- 스프링의 역사 — 1.x XML 시대부터 6.x까지
- 스프링 생태계 지도 — Framework, Boot, Data, Security, Cloud
- 스프링의 4대 핵심 — IoC, DI, AOP, PSA
- 스프링이란 무엇인가 — EJB의 한계와 POJO 철학
Algorithm
맨 처음 ↓- 무작위 알고리즘: 동전을 던져 더 빨라지다
- 근사 알고리즘: 최적을 포기하고 보장을 얻다
- 환원: 문제의 어려움을 옮기는 기술
- 복잡도 클래스: P, NP, PSPACE의 지도
- NP-완전성: 어려운 문제의 경계
- 다각형의 넓이: 신발끈 공식과 픽의 정리
- 스위프 라인: 평면을 쓸어 기하 문제를 풀다
- 선분 교차 판정: 외적과 바운딩 박스
- 볼록 껍질: 그레이엄 스캔과 모노톤 체인
- 외적과 방향 판별: CCW의 모든 것
- 점과 벡터: 계산기하학의 출발점
- 피보나치 계산 기법: 빠른 배가 공식과 피사노 주기
- 행렬 거듭제곱: 점화식을 O(log n)에 푸는 법
- 조합론과 이항계수: nCr을 빠르게 계산하기
- 소인수분해: √n 시도 분할에서 폴라드 로까지
- 에라토스테네스의 체: 소수를 한 번에 거르기
- 모듈러 역원: 나머지 세계의 나눗셈
- 모듈러 거듭제곱: O(log n) 빠른 거듭제곱
- 모듈러 연산: 나머지 세계의 산술
- 최대공약수와 확장 유클리드 알고리즘
- 트라이 응용: 자동완성, 접두사 검색, XOR 트라이
- 접미사 배열(Suffix Array): 문자열의 모든 접미사 정렬하기
- 아호-코라식 알고리즘: 다중 패턴 동시 탐색
- 보이어-무어 알고리즘: 실용적인 고속 문자열 검색
- 마나커 알고리즘: 팰린드롬 부분 문자열 선형 탐색
- Z-알고리즘: 선형 시간 문자열 분석
- 롤링 해시: 부분 문자열 비교와 해시 충돌 방지
- 라빈-카프 알고리즘: 해시 기반 문자열 검색
- KMP 알고리즘: 문자열 검색의 표준
- 비트 조작 (Bit Manipulation): 비트 연산과 마스킹 완전 정복
- 백트래킹: 상태 공간 탐색과 가지치기
- 편집 거리 (Edit Distance): 레벤슈타인 알고리즘 완전 분석
- 최장 공통 부분 수열 (LCS): 역추적과 응용 문제
- 최장 증가 부분 수열 (LIS): O(n²)와 O(n log n)
- 트리 DP (Tree DP): 서브트리 기반 최적화
- 비트마스크 DP: 집합 상태를 정수로 압축하는 기법
- 구간 DP (Interval DP): 팰린드롬·풍선·돌 합치기
- 행렬 연쇄 곱셈 (Matrix Chain Multiplication)
- 동전 교환 문제 (Coin Change): 최솟값과 경우의 수
- 배낭 문제 변형들: 무한 배낭·유계 배낭·분할 배낭
- 0/1 배낭 문제 (0/1 Knapsack Problem)
- 메모이제이션 vs 타뷸레이션: DP 구현 전략 완전 비교
- 동적 프로그래밍 입문 (Dynamic Programming)
- 허프만 코딩 (Huffman Coding)
- 탐욕: 활동 선택 문제 (Activity Selection)
- 탐욕: 구간 스케줄링 (Interval Scheduling)
- 탐욕 알고리즘 (Greedy Algorithm)
- 가장 가까운 두 점 (Closest Pair of Points)
- 분할 정복 (Divide and Conquer)
- 재귀 (Recursion)
- 오프라인 쿼리 처리 (Offline Query Processing)
- Mo의 알고리즘 (Mo's Algorithm)
- 제곱근 분해 (Sqrt Decomposition)
- 카데인 알고리즘 (Kadane's Algorithm)
- 차이 배열 (Difference Array)
- 누적 합 (Prefix Sum)
- 슬라이딩 윈도우 (Sliding Window)
- 투 포인터 (Two Pointers)
- 상위 K개 원소 (Top-K Elements)
- 퀵셀렉트 (Quickselect)
- 중간에서 만나기 (Meet in the Middle)
- 삼분 탐색 (Ternary Search)
- 정답에 이진 탐색(Binary Search on Answer)
- 이진 탐색(Binary Search)
- 선형 탐색(Linear Search)
- 정렬 안정성(Sorting Stability)
- 외부 정렬(External Sorting)
- 팀 정렬(Tim Sort)
- 버킷 정렬(Bucket Sort)
- 기수 정렬(Radix Sort)
- 카운팅 정렬(Counting Sort)
- 힙 정렬(Heap Sort)
- 퀵 정렬(Quick Sort)
- 병합 정렬(Merge Sort)
- 셸 정렬(Shell Sort)
- 삽입 정렬(Insertion Sort)
- 선택 정렬(Selection Sort)
- 버블 정렬(Bubble Sort)
- LCA — 이진 리프팅(Binary Lifting)
- 이분 매칭(Bipartite Matching)
- 최소 컷(Min-Cut)과 최대 유량-최소 컷 정리
- 최대 유량 — 디닉(Dinic) 알고리즘
- 최대 유량 — 포드-풀커슨(Ford-Fulkerson) 알고리즘
- 오일러 경로와 오일러 회로 — 한붓그리기
- 단절점과 단절선 — 그래프의 취약 구조 탐지
- 강한 연결 요소(SCC) — 코사라주와 타잔 알고리즘
- 프림(Prim) 알고리즘 — 그리디 방식으로 MST 확장
- 크루스칼(Kruskal) 알고리즘 — 최소 신장 트리 구성
- 플로이드-워셜(Floyd-Warshall) — 모든 쌍 최단 경로
- 벨만-포드(Bellman-Ford) — 음수 가중치와 음수 사이클 탐지
- A* 탐색 알고리즘 — 휴리스틱으로 더 빠르게
- 다익스트라(Dijkstra) 알고리즘 — 최단 경로의 정석
- 유니온 파인드 (Disjoint Set Union)
- 위상 정렬 (Topological Sort)
- 0-1 BFS — deque를 이용한 O(V+E) 최단 경로
- 다중 소스 BFS (Multi-Source BFS)
- 그래프 DFS (깊이 우선 탐색)
- 그래프 BFS (너비 우선 탐색)
- 그래프 표현 방식 (인접 행렬 · 인접 리스트 · 엣지 리스트)
- 희소 테이블 (Sparse Table)
- k-d 트리 (k-dimensional Tree)
- 펜윅 트리 (Binary Indexed Tree)
- 세그먼트 트리 — Lazy Propagation
- 세그먼트 트리 (Segment Tree)
- 트라이 (Trie)
- 우선순위 큐 (Priority Queue)
- 힙 (Heap)
- B+ 트리 (B+ Tree)
- B 트리 (B-Tree)
- 균형 트리 비교 (Balanced Tree Comparison)
- 레드-블랙 트리 (Red-Black Tree)
- AVL 트리
- 이진 탐색 트리 (Binary Search Tree)
- 트리 순회 (Tree Traversal)
- 이진 트리 (Binary Tree)
- 트리 기초 (Tree Basics)
- LRU 캐시 (Least Recently Used Cache)
- 집합 자료구조 (Set)
- 블룸 필터 (Bloom Filter)
- 일관된 해싱 (Consistent Hashing)
- 개방 주소법 (Open Addressing)
- 충돌 해결 — 분리 체이닝 (Collision Resolution: Separate Chaining)
- 해시 함수 (Hash Function)
- 해시 테이블 (Hash Table)
- 스킵 리스트 (Skip List)
- 단조 스택 (Monotonic Stack)
- 덱 (Deque)
- 원형 큐 (Circular Queue)
- 큐 (Queue)
- 스택 (Stack)
- 마스터 정리 (Master Theorem)
- 점화식 (Recurrence Relations)
- 이중 연결 리스트
- 단일 연결 리스트
- 동적 배열
- 배열의 기초
- 분할 상환 분석 (Amortized Analysis)
- 점근적 표기법 (O, Ω, Θ)
- 빅오(Big-O) 표기법
- 시간·공간 복잡도
- 알고리즘 분석 입문
- 알고리즘이란 무엇인가
Kubernetes
맨 처음 ↓- 프로덕션 준비 체크리스트 — 운영에 올리기 전 점검 목록
- DNS 트러블슈팅 — 서비스 이름이 풀리지 않을 때
- Pending Pod — 스케줄링되지 못하는 Pod 진단하기
- OOMKilled — 메모리 한도를 넘어 강제 종료될 때
- ImagePullBackOff — 이미지를 가져오지 못할 때
- CrashLoopBackOff — 컨테이너가 계속 재시작될 때
- kubectl 디버깅 도구 — describe·logs·exec·debug 완전 활용
- 트러블슈팅 방법론 — 장애를 체계적으로 진단하기
- 재해 복구 — 최악의 상황에 대비하는 DR 전략
- 비용 최적화 — 쿠버네티스 자원 낭비 줄이기
- 멀티 테넌시 — 하나의 클러스터를 안전하게 나눠 쓰기
- 노드 관리 — 추가·격리·교체의 운영 기술
- 클러스터 업그레이드 — 무중단으로 버전 올리기
- 인증서 로테이션 — 만료가 클러스터를 멈추기 전에
- etcd 백업과 복구 — 클러스터 상태를 지키는 마지막 보루
- Argo Rollouts — 카나리·블루그린 배포 자동화
- 프로그레시브 딜리버리 — 위험을 점진적으로 흘려보내는 배포
- Flux — GitOps 툴킷으로 구축하는 자동 배포
- Argo CD — 선언적 GitOps 지속 배포
- GitOps 입문 — Git을 단일 진실 공급원으로
- Kubernetes 감사 로그(Audit Log) — 누가 무엇을 했는가
- Kubernetes Events — 클러스터의 블랙박스 기록
- OpenTelemetry로 구현하는 Kubernetes 분산 트레이싱
- EFK 스택과 Loki — 중앙집중식 로깅 구축
- Kubernetes 로깅 아키텍처 — 관측성의 첫걸음
- kube-state-metrics — Kubernetes 오브젝트 상태 메트릭
- Grafana 대시보드 — Kubernetes 메트릭 시각화
- Prometheus — Kubernetes 모니터링 기초
- Metrics Server — 클러스터 리소스 메트릭 수집
- Image Pull Secrets — 프라이빗 레지스트리 인증
- 이미지 서명 — Cosign과 공급망 보안
- 컨테이너 이미지 스캔 — Trivy와 취약점 관리
- Kustomize Patches & Components — 세밀한 설정 제어
- Kustomize 오버레이 — base/overlays 구조 완전 이해
- Kustomize 기초 — 순수 YAML로 Kubernetes 설정 관리
- Helm Values 전략 — 환경별 오버라이드와 시크릿 분리
- Helm 의존성 관리 — Chart.lock과 서브차트 완전 이해
- Helm Hook — 배포 라이프사이클 확장
- Helm Chart 템플릿 심화 — 함수·파이프라인·제어 흐름
- Kyverno — Kubernetes 네이티브 정책 엔진
- OPA Gatekeeper — 정책 기반 거버넌스
- Admission Webhook — 클러스터 진입 관문
- controller-runtime과 Operator SDK로 Operator 개발하기
- Operator 패턴 — 도메인 지식을 코드로
- Finalizer — 리소스 삭제 전 정리 보장
- API Aggregation Layer — 쿠버네티스 API 확장 제2부
- CRD 심화 — 검증·버전 관리·Conversion Webhook
- Custom Resources와 CRD — 쿠버네티스 API 확장
- Node Cordon과 Drain — 안전한 노드 유지보수 절차
- Descheduler — 실행 중인 Pod를 더 나은 노드로 재배치
- Pod Priority와 Preemption — 중요한 Pod 먼저 배치하기
- Topology Spread Constraints — Pod 분산 배치 최적화
- Taints와 Tolerations — 노드가 Pod를 밀어내는 메커니즘
- Node Affinity와 Pod Affinity — 유연한 스케줄링 제어
- Node Selectors — 파드를 원하는 노드로 유도하는 첫 번째 방법
- Pod Security Admission — PSA 동작 원리와 설정
- Pod Security Standards — 클러스터 보안 정책의 표준 프레임워크
- Seccomp와 AppArmor — 커널 레벨 보안 프로파일
- 쿠버네티스 Security Context — 파드 보안 설정
- 쿠버네티스 RBAC — 역할 기반 접근 제어
- 쿠버네티스 ServiceAccount — 워크로드 ID와 권한
- External Secrets Operator — 외부 시크릿 저장소를 K8s로
- Sealed Secrets — GitOps 친화적 시크릿 관리
- 쿠버네티스 시크릿 관리 심화 — Vault, ESO, 암호화
- 쿠버네티스 NetworkPolicy — 파드 간 트래픽 제어
- 쿠버네티스 듀얼스택 네트워킹 — IPv4와 IPv6 동시 운영
- 서비스 메시 입문 — Istio와 Linkerd로 마이크로서비스 네트워크 제어하기
- Gateway API — 쿠버네티스 차세대 Ingress 표준
- 쿠버네티스 Ingress 컨트롤러 완전 정복
- 쿠버네티스 DNS와 CoreDNS 완전 정복
- 헤드리스 서비스(Headless Service) 완전 정복
- Endpoints와 EndpointSlice 완전 정복
- 쿠버네티스 Service 타입 완전 정복
- 쿠버네티스 CNI 플러그인 비교 — Calico·Flannel·Cilium·Weave
- 쿠버네티스 CNI — 컨테이너 네트워크 인터페이스 완전 이해
- 쿠버네티스 네트워킹 모델 — Pod 간 통신의 기본 원칙
- 쿠버네티스 Stateful 스토리지 패턴 — StatefulSet 스토리지 설계
- 쿠버네티스 Local Persistent Volume — 노드 로컬 스토리지 활용
- 쿠버네티스 Volume Snapshots — 볼륨 스냅샷과 복원
- 쿠버네티스 CSI 드라이버 — Container Storage Interface 완전 이해
- 쿠버네티스 StorageClass — 동적 프로비저닝의 설계 도구
- 쿠버네티스 PersistentVolume과 PVC — 지속형 스토리지의 핵심
- 쿠버네티스 Ephemeral Volumes — Pod 수명과 함께하는 임시 볼륨
- 쿠버네티스 Volume — 컨테이너 스토리지의 기초
- 쿠버네티스 Karpenter — 차세대 노드 자동 프로비저닝
- 쿠버네티스 Cluster Autoscaler — 노드 수 자동 조정
- 쿠버네티스 VPA — Pod 수직 자동 스케일링
- 쿠버네티스 KEDA — 이벤트 기반 자동 스케일링
- 쿠버네티스 HPA 커스텀·외부 메트릭 — Prometheus Adapter와 외부 메트릭 연동
- 쿠버네티스 HPA — Pod 수평 자동 스케일링
- 쿠버네티스 ResourceQuota — 네임스페이스 총 리소스 사용량 제한
- 쿠버네티스 LimitRange — 네임스페이스 내 리소스 기본값과 제한
- 쿠버네티스 PodDisruptionBudget — 자발적 중단으로부터 Pod를 보호하는 방법
- 쿠버네티스 Pod 퇴출(Eviction) — kubelet의 리소스 보호 메커니즘
- 쿠버네티스 QoS 클래스 — Guaranteed, Burstable, BestEffort
- 쿠버네티스 Resources Requests와 Limits — 노드 자원 배분
- Liveness · Readiness · Startup Probe — 자가 치유와 트래픽 제어
- 쿠버네티스 사이드카 패턴 — 공유 리소스로 기능 확장
- 쿠버네티스 Init Container — 메인 컨테이너 시작 전 준비 작업
- 쿠버네티스 Job과 CronJob — 일회성·반복 작업
- StatefulSet 스토리지 운영 — PVC 보존과 마이그레이션
- 쿠버네티스 StatefulSet — 순서와 영속성이 보장되는 Pod
- 쿠버네티스 DaemonSet 완전 이해
- 쿠버네티스 Deployment 배포 전략 완전 정복
- Deployment progressDeadlineSeconds와 배포 타임아웃
- maxSurge와 maxUnavailable 심층 분석
- 쿠버네티스 Rolling Update와 Rollback
- ReplicationController vs Deployment — 진화의 역사
- 쿠버네티스 ReplicaSet 완전 이해
- 쿠버네티스 Owner References와 가비지 컬렉션
- 쿠버네티스 Annotations 실전 활용
- 쿠버네티스 Labels와 Selectors 완전 이해
- Ephemeral Debug Container로 실행 중인 Pod 디버깅하기
- 멀티 컨테이너 파드 패턴: Sidecar, Ambassador, Adapter
- 파드 생명주기 훅: PostStart와 PreStop
- 파드(Pod) 생명주기 완전 이해
- kubectl 플러그인 매니저 krew 완전 정리
- 선언형 vs 명령형: kubectl apply와 create의 철학적 차이
- 쿠버네티스 YAML 매니페스트 구조 완전 해부
- kubectl context와 kubeconfig 완전 정복
- kubectl 기본 명령어 완전 정리
- 로컬 쿠버네티스 클러스터 구축: kind, minikube, k3d 비교
- 컨테이너 런타임: CRI, containerd, runc 완전 해부
- kube-proxy: 쿠버네티스 네트워크 프록시
- kubelet: 노드의 핵심 에이전트
- 컨트롤러 매니저(Controller Manager) 이해
- 쿠버네티스 스케줄러(Scheduler) 동작 원리
- Kubernetes API Server 완전 이해
- etcd: 클러스터의 두뇌 저장소
- 컨트롤 플레인(Control Plane) 이해
- 쿠버네티스 클러스터 아키텍처
- 왜 컨테이너 오케스트레이션이 필요한가?
- 쿠버네티스란 무엇인가?
- Helm으로 쿠버네티스 패키지 관리하기
- 쿠버네티스 Namespace로 클러스터 격리하기
- ConfigMap과 Secret으로 설정 분리하기
- 쿠버네티스 Ingress 기초
- 쿠버네티스 Service 기초
- 쿠버네티스 Deployment 기초
- 쿠버네티스 파드(Pod) 기초
- Kubernetes vs Docker Compose: 무엇을 선택해야 할까?
Security
맨 처음 ↓- 보안 감사 로깅: 신뢰할 수 있는 기록 남기기
- 보안 컴플라이언스 입문: GDPR·PCI-DSS·ISO 27001 기초
- 침해사고 대응: 탐지부터 복구까지의 IR 프로세스
- 보안 모니터링과 SIEM: 공격을 탐지하는 관측 체계
- 버그 바운티와 취약점 공개: 외부 연구자와 협력하는 법
- 침투 테스트 입문: 모의 해킹의 절차와 방법론
- 퍼징(Fuzzing): 예상 밖의 입력으로 숨은 취약점 찾기
- SAST·DAST·IAST: 자동화 보안 테스트 도구 비교와 선택
- OWASP ASVS: 애플리케이션 보안 검증 표준 활용 가이드
- Secure SDLC: 개발 생명주기에 보안을 내재화하는 법
- 공급망 보안: 의존성 하나가 시스템 전체를 위협한다
- 파일 업로드 보안: 악성 파일 업로드 방어 전략
- 입력 검증과 출력 인코딩: 인젝션 공격의 근본 방어
- Rate Limiting: API와 웹 서비스 속도 제한 구현
- DDoS 완화: 분산 서비스 거부 공격 방어 전략
- SBOM: 소프트웨어 자재명세서로 공급망 가시성 확보
- Dependency Confusion: 공급망 패키지 하이재킹 공격
- 스토리지 버킷 잘못된 설정: S3 공개 노출 방어
- 클라우드 IAM 잘못된 설정: 과도한 권한과 방어 전략
- 컨테이너 보안: Docker·Kubernetes 취약점과 방어 전략
- WAF: 웹 애플리케이션 방화벽 원리, 배포 전략, 우회 방어
- API 키 관리: 생성·저장·스코프·로테이션·폐기 전략 완전 가이드
- API Rate Limiting: 토큰 버킷·슬라이딩 윈도우·분산 환경 구현
- GraphQL 보안: 인트로스펙션·깊이 제한·배치 공격·인가 취약점 방어
- BOLA와 BFLA 심층 분석: 객체·기능 수준 권한 실패 완전 해부
- OWASP API Security Top 10: 현실 공격 시나리오와 방어 코드
- REST API 보안: 설계부터 배포까지 실전 체크리스트
- API 보안 개요: REST·GraphQL·gRPC API를 안전하게 설계하는 원칙
- 시크릿 관리: Vault·AWS Secrets Manager로 자격증명 안전하게 보관하기
- 포스트 퀀텀 암호학 입문: 양자 컴퓨터 시대의 암호 전환 전략
- Certificate Pinning: 인증서 고정으로 MITM 공격 차단하기
- TLS/HTTPS: 핸드셰이크 동작 원리와 보안 설정 완전 가이드
- 키 관리와 순환: 암호화 키 생명주기와 안전한 운영
- 저장 데이터·전송 데이터 암호화: 레이어별 전략과 구현
- CSPRNG: 암호학적으로 안전한 난수 생성의 원리와 실무
- 인증서와 신뢰 체인: PKI와 CA의 동작 원리
- 디지털 서명: RSA-PSS·ECDSA·Ed25519 동작 원리와 취약점
- 키 유도 함수: PBKDF2·bcrypt·scrypt·Argon2 완전 비교
- HMAC: 해시 기반 메시지 인증 코드의 원리와 활용
- 키 교환 프로토콜: Diffie-Hellman과 ECDH의 동작 원리
- RSA vs ECC: 공개키 암호화 알고리즘 완전 비교
- AES 운용 모드: ECB·CBC·GCM의 보안 차이
- 해싱 vs 암호화: 언제 무엇을 쓸까
- 대칭 암호화 vs 비대칭 암호화
- HSTS: 강제 HTTPS와 Preload의 모든 것
- HTTP 보안 헤더 완전 가이드
- 서브리소스 무결성(SRI): CDN 공급망 공격 방어
- 클릭재킹: 보이지 않는 레이어의 함정
- 쿠키 보안: Secure·HttpOnly·SameSite 완전 정복
- postMessage 보안: 크로스 오리진 통신 안전하게
- iframe sandbox: 안전한 임베드를 위한 격리
- Trusted Types: DOM XSS 방어의 새로운 표준
- CSP Nonce와 Hash: 인라인 스크립트 안전하게 허용하기
- 콘텐츠 보안 정책(CSP): XSS의 마지막 방어선
- CORS 보안: 잘못된 설정이 SOP를 무력화한다
- 동일 출처 정책(SOP): 웹 보안의 가장 중요한 경계선
- 비즈니스 로직 취약점: 규칙의 허점을 노리다
- 레이스 컨디션: 동시성의 틈을 노리는 공격
- 오픈 리다이렉트: 신뢰 도메인을 피싱의 발판으로
- Host 헤더 인젝션: 신뢰할 수 없는 호스트 값
- 웹 캐시 포이즈닝: CDN을 무기로 바꾸는 공격
- HTTP 요청 스머글링: 프록시 간 불일치 악용
- ReDoS: 정규표현식을 이용한 서비스 거부 공격
- 프로토타입 오염: JavaScript 공격 심층 분석
- 로깅과 모니터링 실패: 침해를 놓치는 이유
- 취약한 인증 메커니즘 탐구하기
- 안전하지 않은 역직렬화: RCE로 이어지는 위험
- XXE 인젝션: XML 외부 엔티티 공격 완전 해설
- 민감 데이터 노출: 정보 유출 방지하기
- 보안 설정 오류: 잘못된 기본 설정의 위험
- 매스 어사인먼트: 자동 속성 바인딩의 함정
- Path Traversal: 경로 순회로 서버 파일 탈취하기
- IDOR: 불안전한 직접 객체 참조 — 가장 흔한 API 취약점
- Broken Access Control: 접근 제어 취약점 — OWASP Top 1위
- SSRF와 클라우드 메타데이터: AWS/GCP/Azure 자격증명 탈취
- SSRF: 서버 사이드 요청 위조 — 내부망을 여는 취약점
- CSRF와 SameSite: 현대적 쿠키 보안의 모든 것
- CSRF: 사이트 간 요청 위조 공격의 원리와 방어
- DOM 기반 XSS: 서버를 거치지 않는 클라이언트 사이드 공격
- Stored XSS: 저장형 크로스사이트 스크립팅의 위험성과 방어
- Reflected XSS: 반사형 크로스사이트 스크립팅 완전 분석
- XSS 완전 정복: 크로스 사이트 스크립팅 개요
- 템플릿 인젝션(SSTI): 서버 사이드 코드 실행 취약점
- 커맨드 인젝션: OS 명령어 탈취 공격과 방어
- NoSQL 인젝션: MongoDB와 쿼리 조작 공격
- 블라인드 SQL 인젝션: 응답 없이 데이터 훔치기
- SQL 인젝션: 공격 원리와 방어 완전 정복
- 인젝션 취약점 완전 정복: 개요와 공통 원리
- OWASP Top 10: 가장 위험한 웹 취약점 개관
- 크리덴셜 스터핑: 공격 원리와 방어 전략
- ABAC: 속성 기반 접근 제어의 원리와 구현
- RBAC: 역할 기반 접근 제어 설계와 구현
- SSO(Single Sign-On) 구현과 보안 함정
- WebAuthn과 패스키: 피싱 불가능한 인증
- 다중 인증(MFA): SMS부터 패스키까지
- OpenID Connect: OAuth 2.0 위에 인증 레이어 추가
- OAuth 2.0 PKCE: 공개 클라이언트 보안
- OAuth 2.0 완전 이해: 흐름과 보안
- Refresh Token Rotation: 탈취 감지와 자동 갱신
- 토큰 보안 모범 사례: 저장·전송·폐기
- JWT 알고리즘 혼동 공격: RS256을 HS256으로 우회하기
- JWT 보안: 올바른 사용법과 취약점
- 세션 하이재킹(Session Hijacking) 완전 정복
- 세션 고정(Session Fixation) 공격과 방어
- 세션 관리의 핵심 원칙
- 무차별 대입 공격 방어 전략
- 강력한 비밀번호 정책 설계하기
- HTTP 보안 헤더 총정리
- 제로 트러스트(Zero Trust): '아무도 믿지 마라'
- 최소 권한 원칙(PoLP): 권한을 최소화하는 이유
- 심층 방어(Defense in Depth): 다층 보안 전략
- 솔트와 페퍼로 해시 강화하기
- 비밀번호 해싱(bcrypt·argon2)
- 인증과 인가의 차이
- HTTP 프로토콜과 보안 기초
- 주요 웹 공격 유형 한눈에 보기
- 보안 사고방식 기르기
- 공격 표면 이해하기
- 위협 모델링 입문
- 정보보안 3요소(CIA) 완전 이해
- 웹 보안이란 무엇인가
Network
맨 처음 ↓- 웹훅(Webhook) — 역방향 HTTP 콜백
- Server-Sent Events — 서버에서 흘려보내는 이벤트
- GraphQL over HTTP — 단일 엔드포인트의 설계
- Richardson 성숙도 모델 — REST의 4단계
- REST 원칙 — 자원, 표현, 무상태
- multipart/form-data — 파일 업로드의 내부
- OAuth 2.0을 HTTP 레벨에서 보기
- HTTP 인증 스킴 심화 — Digest부터 WWW-Authenticate까지
- HTTP 인증 — Basic과 Bearer
- QUIC 심화 — 0-RTT, 연결 마이그레이션, 패킷 구조
- HTTP/3와 QUIC — UDP 위에서 다시 짠 전송
- HPACK 헤더 압축과 서버 푸시
- HTTP/2 흐름 제어와 우선순위
- HTTP/2 스트림과 프레임 — 바이너리 프레이밍 계층
- HTTP/2 멀티플렉싱 — 하나의 연결로 동시에
- HTTP/1.1 심화 — 지속 연결·파이프라이닝·HOL 블로킹
- HTTP/1.0 vs HTTP/1.1 — 무엇이 달라졌나
- 리다이렉트 심화 — 301·302·303·307·308 정확히 구분하기
- HTTP 리다이렉트 완전 정복 — 3xx와 Location
- Range 요청 완전 정복 — 부분 전송과 이어받기
- Zstandard(zstd) 압축 완전 정복 — 차세대 HTTP 압축
- HTTP 압축 완전 정복 — gzip과 Brotli
- Transfer-Encoding vs Content-Encoding — 두 인코딩의 차이 완전 정복
- HTTP 스트리밍 완전 정복 — 버퍼링 없이 응답 흘려보내기
- 청크 전송 인코딩 완전 정복 — Transfer-Encoding: chunked
- Keep-Alive와 파이프라이닝 — 영속 연결의 원리와 한계
- CORS 프리플라이트 완전 정복 — OPTIONS 요청과 인증 정보 규칙
- CORS 완전 정복 — 교차 출처 리소스 공유의 원리
- 조건부 요청 심화 — If-Match, If-Unmodified-Since, If-Range와 평가 순서
- ETag 완전 정복 — 강한·약한 검증자, 생성 전략, If-Match 낙관적 잠금
- 캐시 신선도와 재검증 완전 정복 — max-age, Age, stale-while-revalidate
- Cache-Control 완전 정복 — 캐시 지시어 완전 해설
- HTTP 세션 관리 완전 정복 — 쿠키 세션, Redis, JWT 비교
- 쿠키 보안 프리픽스 완전 정복 — __Host- 와 __Secure-
- 쿠키 속성 완전 정복 — Secure, HttpOnly, SameSite, Max-Age
- HTTP 쿠키 완전 정복 — Set-Cookie와 Cookie 헤더
- Accept 헤더 패밀리 완전 해설 — Accept, Accept-Language, Accept-Encoding
- HTTP 콘텐츠 협상(Content Negotiation) 완전 정복
- Content-Type과 MIME 타입 완전 정복
- HTTP 헤더 카테고리 완전 해설 — 공통·요청·응답·표현 헤더
- HTTP 헤더 완전 정복 — 분류와 핵심 개요
- 4xx 클라이언트 오류와 5xx 서버 오류 — 오류 코드 완전 분석
- 2xx 성공과 3xx 리다이렉션 — 상태 코드 완전 분석
- HTTP 상태 코드 완전 정복 — 5개 범주 개요
- PUT vs PATCH vs DELETE — 수정과 삭제의 정확한 의미
- GET vs POST — 언제 어떤 메서드를 써야 할까
- HTTP 메서드 안전성과 멱등성 — 재시도 설계의 기반
- HTTP 메서드 완전 정복 — GET·POST·PUT·PATCH·DELETE
- HTTP 메시지 해부 심화 — 바이트 레벨 분석
- HTTP 요청·응답 메시지 해부 — 구조와 형식
- URL과 URI 완전 정복 — 구조와 컴포넌트
- HTTP란 무엇인가 — 웹 통신의 기초
- traceroute · mtr로 네트워크 경로 추적하기
- tcpdump · Wireshark로 패킷 직접 캡처하기
- dig · nslookup으로 DNS 쿼리 직접 분석하기
- ss · netstat로 네트워크 연결 상태 파악하기
- CDN 심화 — 엣지 로직·다계층 캐시·Anycast·성능 최적화
- CDN 완전 정복 — 엣지 서버와 캐싱 전략
- L4 · L7 로드 밸런서 완전 정복
- 로드 밸런싱 완전 정복 — 개념부터 알고리즘·헬스 체크까지
- 프록시 완전 정복 — 포워드 프록시와 리버스 프록시
- VPN 완전 정복 — 터널링과 암호화로 안전한 통신
- 방화벽 완전 정복 — 패킷 필터링부터 NGFW까지
- HTTPS 완전 정복 — HTTP에 TLS를 더하면
- 인증서와 PKI — X.509, CA 체인, 신뢰 구축
- mTLS — 상호 TLS 인증 완전 정리
- TLS 세션 재개 — Session ID, Session Ticket, PSK
- TLS 암호화 스위트 해부 — 키 교환부터 MAC까지
- TLS 1.2 vs TLS 1.3 — 무엇이 달라졌는가?
- TLS 핸드셰이크 완전 분석 — ClientHello부터 Finished까지
- TLS/SSL 개요: HTTPS의 핵심
- WebSocket 프로토콜 완전 정복
- DoH와 DoT: DNS 암호화
- DNSSEC: DNS 보안 확장
- DNS 캐싱과 TTL: 빠른 응답의 비밀
- DNS 재귀·반복 질의: 해석기가 답을 찾는 두 가지 방법
- DNS 레코드 타입: A, AAAA, CNAME, MX, TXT의 역할
- DNS 이름 해석: 도메인이 IP로 변환되는 과정
- UDP 활용 사례: 빠른 전송이 필요한 곳
- 혼잡 제어 알고리즘 심층 비교: Reno, CUBIC, BBR
- TCP 혼잡 제어: AIMD, Slow Start, CUBIC의 원리
- MSS, MTU, PMTUD: 세그먼트 크기 결정의 모든 것
- TCP 슬라이딩 윈도우: 파이프라인 전송의 원리
- TCP 흐름 제어: 수신 윈도우와 슬라이딩 윈도우
- TCP 순서 번호와 ACK: 신뢰성의 수학적 기반
- TCP TIME_WAIT 완전 정복: 왜 생기고 어떻게 다루는가
- TCP 상태 머신: 11가지 상태와 전이 완전 해부
- TCP 연결 종료: 4-way 핸드셰이크와 Half-close
- TCP 3-way 핸드셰이크: 연결 수립의 모든 것
- TCP vs UDP: 신뢰성과 속도의 트레이드오프
- 포트와 소켓: 프로세스 간 통신의 끝점
- 전송 계층: TCP와 UDP의 역할과 구조
- DHCP: 동적 IP 주소 할당의 원리
- ICMP와 ping: 네트워크 진단의 기본 도구
- NAT: 네트워크 주소 변환의 모든 것
- BGP: 인터넷을 연결하는 경계 게이트웨이 프로토콜
- 라우팅 테이블과 LPM: 최장 프리픽스 매칭
- 라우팅 기초: 패킷이 목적지를 찾아가는 방법
- IPv6 SLAAC: 상태 비저장 주소 자동 구성
- 브로드캐스트·멀티캐스트·애니캐스트: IP 전송 방식 완전 정리
- TTL: 패킷의 유효 기간과 traceroute의 원리
- IP 단편화와 재조립: MTU를 넘는 패킷의 운명
- CIDR과 주소 집약: IP 주소 공간을 효율적으로 관리하기
- STP: 스패닝 트리 프로토콜로 루프를 제거하다
- VLAN: 논리적 네트워크 분리와 802.1Q 태깅
- 스위치와 MAC 학습: 이더넷 스위칭의 동작 원리
- 오류 감지와 CRC: 데이터 무결성 보장의 핵심
- 신호와 인코딩: 데이터를 전파로 바꾸는 법
- 회선 교환 vs 패킷 교환: 데이터 전달 방식의 두 철학
- RTT와 지터: 네트워크 지연의 두 얼굴
- 서브네팅 완전 이해
- IPv4 vs IPv6 완전 비교
- IP 주소 지정 완전 이해
- ARP 완전 이해
- 이더넷 완전 이해
- MAC 주소란 무엇인가
- 대역폭, 처리량, 지연이란
- TCP/IP 모델 완전 이해
- OSI 7계층 완전 이해
- 네트워크란 무엇인가
React
맨 처음 ↓- Storybook — 컴포넌트 주도 개발과 문서화
- 커스텀 훅 테스트하기 — renderHook 완전 가이드
- MSW로 API 모킹하기 — 네트워크 레벨 테스트
- user-event — 실제 사용자처럼 상호작용 테스트하기
- Testing Library 쿼리 완전 정리 — getBy, queryBy, findBy
- React Testing Library — 사용자 관점의 테스트
- TanStack Query Mutations — 데이터 변경과 낙관적 업데이트
- TanStack Query — 서버 상태 관리의 표준
- Zustand — 가볍고 단순한 상태 관리
- RTK Query — Redux에서 서버 상태 관리하기
- Redux Slices 패턴 — 도메인 기반 상태 구조화
- Redux Toolkit 완전 가이드 — createSlice와 configureStore
- Context vs 외부 상태 관리 — 언제 무엇을 쓸까?
- React 상태 관리 전략 개요 — 내장 훅부터 외부 라이브러리까지
- ref를 Props로 전달하기 — forwardRef 없이 ref 넘기기
- useFormStatus — 폼 상태를 자식 컴포넌트에서 읽기
- useOptimistic으로 낙관적 UI 업데이트 구현하기
- useActionState로 Action 결과 상태 관리하기
- React 19 Actions — 폼과 비동기 처리의 새로운 방식
- use() 훅 — Promise와 Context를 조건문 안에서 읽기
- useTransition vs useDeferredValue 비교
- useDeferredValue로 후순위 업데이트 분리
- useTransition으로 UI 응답성 개선
- 동시성(Concurrent) 기능 개요
- React.lazy와 코드 스플리팅
- Suspense와 데이터 페칭
- Suspense로 비동기 UI 선언적으로 처리하기
- 에러 경계 심화: 복구·리셋·에러 추적
- 에러 경계(Error Boundary)로 안전한 UI 만들기
- React에서 애니메이션 구현하기
- 포커스 관리와 키보드 내비게이션
- React 접근성(a11y) 기초 — 스크린 리더와 시맨틱
- Portal 심화 — 모달과 토스트 직접 구현
- React Portal — DOM 경계 너머에 렌더링하기
- 가상화(Virtualization)로 긴 목록 성능 최적화
- React DevTools Profiler 활용법
- React 성능 최적화 종합 가이드
- React.memo — 컴포넌트 메모이제이션 완전 정복
- Context + useReducer 아키텍처 — 상태와 액션 분리
- Context 분리 전략 — 역할별로 나눠 리렌더 최소화
- Context 성능 최적화 — 불필요한 리렌더 막기
- useSyncExternalStore로 외부 상태 구독하기
- useId — 고유 ID 생성 훅
- useFetch 커스텀 훅 — 데이터 페칭 완전 캡슐화
- useDebounce 커스텀 훅 — 입력 최적화
- useLocalStorage 커스텀 훅 — 브라우저 저장소 연동
- 커스텀 훅 만들기 — 로직을 훅으로 분리하는 법
- useCallback 완전 정복 — 함수 메모이제이션
- useMemo 완전 정복 — 계산 결과 메모이제이션
- 데이터 페칭 패턴 비교 — useEffect, SWR, TanStack Query
- AbortController로 fetch 요청 취소하기
- Effect 경쟁 조건 — 오래된 응답이 나중에 도착할 때
- Effect가 필요 없는 상황들
- useReducer — 복잡한 상태 로직을 컴포넌트 밖으로
- useContext — Prop Drilling 없이 전역 상태 공유
- Callback Refs — DOM 연결 시점을 감지하는 ref
- useImperativeHandle — ref로 메서드 노출하기
- forwardRef — 부모가 자식 DOM을 제어하는 방법
- useRef — DOM 참조와 렌더 사이 값 유지
- cleanup 함수 — Effect를 되돌리는 반환값
- 의존성 배열 — Object.is 비교와 흔한 함정들
- useEffect — 부수효과와 외부 시스템 동기화
- 훅의 규칙 — 최상위에서만, 함수 컴포넌트에서만
- 하이드레이션 — SSR과 React 연결하기
- StrictMode — 개발 환경 품질 검사 도구
- key와 재조정 — 리스트에서 key가 하는 일
- 재조정(Reconciliation) — React Diffing 알고리즘
- Virtual DOM — 개념과 작동 원리
- 함수형 컴포넌트 생명주기 — 마운트, 업데이트, 언마운트
- React 렌더링 모델 — Render 단계와 Commit 단계
- Prop Drilling 문제와 해결책
- key를 이용한 컴포넌트 리셋
- 고차 컴포넌트 (HOC)
- 렌더 프롭 패턴
- 컴파운드 컴포넌트 패턴
- 컴포지션 vs 상속
- 상태 끌어올리기 (Lifting State Up)
- React Hook Form으로 폼 관리
- React 폼 유효성 검사
- 비제어 컴포넌트와 useRef 폼 처리
- 제어 컴포넌트와 폼 처리
- 자동 배칭(Automatic Batching): React 18
- 상태 배치(State Colocation): 상태는 쓰는 곳에
- 파생 상태와 계산된 값
- 불변성 업데이트 패턴
- 함수형 업데이트: 이전 상태를 안전하게 읽는 법
- Props 스프레딩과 전달 패턴
- children prop으로 컴포넌트 조합하기
- React.Fragment 완전 이해
- JSX 심화: 컴파일 과정과 표현식 규칙
- useState로 상태 관리하기
- 상태(state)란 무엇인가
- 이벤트 처리
- key의 역할과 올바른 사용
- 리스트 렌더링
- 조건부 렌더링
- props로 데이터 전달하기
- 컴포넌트의 개념
- JSX 문법 이해하기
- React란 무엇인가
Next.js
맨 처음 ↓- Pages에서 App Router로 마이그레이션하기
- 프로덕션 ISR — 점진적 정적 재생성 실전 패턴
- Docker로 셀프 호스팅 — Next.js를 직접 배포하는 방법
- Vercel 배포 — Next.js 앱을 프로덕션에 올리는 최선의 방법
- E2E 테스트 — Playwright로 전체 흐름 검증하기
- 테스팅 — Jest와 React Testing Library로 단위 테스트 작성하기
- 에러 모니터링 — Sentry로 프로덕션 오류 추적하기
- MDX — Next.js에서 마크다운으로 콘텐츠 작성하기
- 국제화(i18n) — Next.js에서 다국어 지원 구현하기
- 성능 최적화 — Core Web Vitals 개선 전략
- 번들 분석 — @next/bundle-analyzer로 번들 크기 진단하기
- 동적 임포트 — next/dynamic으로 코드 스플리팅하기
- 스크립트 최적화 — next/script로 서드파티 스크립트 제어하기
- 폰트 최적화 — next/font로 CLS 제로 달성하기
- 이미지 최적화 — next/image 완전 가이드
- sitemap.xml과 robots.txt — 검색 엔진 크롤링 제어
- 동적 OG 이미지 — ImageResponse로 SNS 카드 생성
- generateMetadata — 동적 메타데이터 심화
- Metadata API — SEO를 위한 메타데이터 설정
- 라우트 보호 패턴 — Middleware와 컴포넌트 레벨 방어
- Auth.js(NextAuth) — 소셜 로그인과 세션 관리
- 인증 구현 — 세션과 토큰 기반 인증
- Middleware matcher — 실행 범위 제어
- Middleware — 요청 가로채기와 전처리
- cookies와 headers — 요청 정보 읽기
- Route Handlers — API 엔드포인트 만들기
- Server Action 보안 — 인증과 인가
- Server Action 입력 검증 — Zod로 안전하게
- useOptimistic — 낙관적 UI 업데이트
- useActionState — 액션 상태 관리
- Form Actions — 폼과 Server Action 연결
- Server Actions — 서버에서 실행되는 함수
- Edge Runtime vs Node.js Runtime — 실행 환경 선택 가이드
- Partial Prerendering — 정적과 동적의 공존
- Streaming과 Suspense — 점진적 렌더링
- generateStaticParams — 동적 라우트 정적 생성
- 정적 vs 동적 렌더링 심화
- 렌더링 전략 — 정적·동적·스트리밍
- ISR과 온디맨드 재검증 — revalidate 완전 이해
- Data Cache 심층 분석
- Next.js 캐싱 전체 구조 한눈에 보기
- fetch 캐시 옵션 완전 정복
- 클라이언트 데이터 패칭 — SWR과 TanStack Query
- Request Memoization — 동일 요청 자동 중복 제거
- 서버 데이터 패칭 — fetch, async 컴포넌트, 중복 제거
- 병렬 라우트와 인터셉팅 라우트 — 모달과 슬롯
- loading.tsx와 error.tsx — 스트리밍과 에러 경계
- 라우트 세그먼트 설정 — dynamic, revalidate, runtime
- 라우트 그룹 — URL 영향 없이 레이아웃 나누기
- Catch-all 라우트 — 가변 경로 세그먼트 처리
- 동적 라우트 — [slug]로 무한한 URL 처리하기
- 서버·클라이언트 컴포넌트 합성 패턴
- 서버 컴포넌트 vs 클라이언트 컴포넌트 — 무엇을 언제 쓸까
- Next.js template.tsx — 페이지마다 초기화되는 특별한 레이아웃
- Next.js 레이아웃 — 중첩 레이아웃과 루트 레이아웃
- 환경 변수 완전 정복 — .env 파일부터 NEXT_PUBLIC까지
- useRouter로 프로그래매틱 내비게이션 하기
- next/link로 페이지 이동하기
- 파일 기반 라우팅 완전 정복
- app/ 디렉토리의 특수 파일들 — layout, page, loading, error
- Next.js 프로젝트 구조 완전 이해
- App Router vs Pages Router — 무엇을 선택해야 할까
- Next.js 프로젝트 시작하기 — 설치부터 첫 실행까지
- Next.js란 무엇인가 — React 위의 풀스택 프레임워크
Backend
- Supabase란 무엇인가? NEW