기술계보 핵심정리

폰 노이만 구조 (1945)
  ↓
하버드 구조 (분리 메모리)
  ↓
CISC (1970s) - x86, 복잡한 명령어
  ↓
RISC (1980s) - ARM, MIPS, 단순 명령어, 파이프라인 최적화
  ↓
슈퍼스칼라 (1990s) - 다중 파이프라인, 비순차 실행
  ↓
멀티코어 (2000s) - 전력 한계, 병렬 처리
  ↓
헤테로지니어스 (2010s~) - big.LITTLE, CPU+GPU+NPU

SRAM (1960s) - 빠름, 비쌈 → 캐시용
  ↓
DRAM (1970s) - 느림, 저렴 → 주기억장치
  ↓
L1/L2 캐시 (1980s) - 속도 격차 해소
  ↓
L3 공유 캐시 (2000s) - 멀티코어 지원
  ↓
HBM/HBM2 (2010s~) - 고대역폭 메모리, GPU/AI용
  ↓
CXL (2020s~) - 메모리 풀링, 캐시 일관성

물리 메모리 직접 접근 (초기)
  ↓
세그멘테이션 (논리적 분할)
  ↓
페이징 (고정 크기, 4KB)
  ↓
다단계 페이지 테이블 (메모리 절약)
  ↓
TLB (Translation Lookaside Buffer) - 주소 변환 캐시
  ↓
Huge Page (2MB/1GB) - TLB 효율, 대규모 메모리

ILP (Instruction Level) - 파이프라인, 슈퍼스칼라
  ↓
TLP (Thread Level) - SMT, Hyper-Threading
  ↓
DLP (Data Level) - SIMD, SSE, AVX
  ↓
TLP (Task Level) - 멀티코어, 분산 시스템

CPU (범용 연산)
  ↓
GPU (SIMT, 병렬 연산, 2000s~)
  ↓
TPU (Google, Tensor 연산 특화, 2016)
  ↓
NPU (모바일/엣지, 2010s~)
  ↓
MoE 전용 칩 (2020s~)

모놀리식 다이 (전통, 단일 칩)
  ↓
SoC (System on Chip) - 기능 통합
  ↓
Chiplet (2020s~) - 모듈 분리, UCIe 표준
  - 수율 향상, 이기종 공정 조합
  ↓
3D 패키징 (TSV, HBM 적층)

단일 프로세스 (Batch)
  ↓
멀티프로그래밍 (시분할)
  ↓
멀티프로세싱 (SMP)
  ↓
멀티스레딩 (경량 프로세스)
  ↓
컨테이너 (Namespace + Cgroup, 2013~)
  ↓
서버리스 (FaaS, 2014~)

FCFS (First Come First Served)
  ↓
SJF (Shortest Job First)
  ↓
Round Robin (시분할)
  ↓
Priority + Aging (우선순위 + 기아 방지)
  ↓
Multilevel Feedback Queue (적응형)
  ↓
CFS (Completely Fair Scheduler, Linux 2.6.23~)

고정 분할
  ↓
동적 분할 (Best-Fit, First-Fit)
  ↓
페이징 (외부 단편화 해결)
  ↓
세그멘테이션 + 페이징
  ↓
가상 메모리 (요구 페이징)
  ↓
Copy-on-Write (fork 최적화)
  ↓
메모리 압축 (zRAM, zswap)

FAT (1977) - MS-DOS, 단순
  ↓
ext2 (1993) - Linux, i-node
  ↓
NTFS (1993) - Windows NT, 저널링
  ↓
ext3 (2001) - 저널링 추가
  ↓
ext4 (2008) - 대용량, Extent
  ↓
Btrfs/ZFS (2000s~) - CoW, 스냅샷, 압축
  ↓
OverlayFS (2014~) - 컨테이너 이미지

chroot (1982) - 루트 격리
  ↓
FreeBSD Jail (2000) - OS 수준 가상화
  ↓
Solaris Zones (2004)
  ↓
LXC (2008) - Linux Container
  ↓
Docker (2013) - 컨테이너 이미지 표준화
  ↓
Kubernetes (2014) - 컨테이너 오케스트레이션

strace/ptrace (시스템 콜 추적)
  ↓
DTrace (2005, Solaris)
  ↓
SystemTap (Linux)
  ↓
eBPF (2014~) - 커널 내 프로그래밍, 관찰성 혁명

IPv4 (1981) - 32bit, 43억 주소
  ↓
NAT (1994) - 주소 부족 임시 해결
  ↓
IPv6 (1998) - 128bit, 무한 주소
  ↓
Dual Stack (IPv4+IPv6 공존)

HTTP/0.9 (1991) - 단순 GET
  ↓
HTTP/1.0 (1996) - 헤더, POST
  ↓
HTTP/1.1 (1997) - Keep-Alive, 파이프라이닝
  ↓
HTTP/2 (2015) - 멀티플렉싱, 서버 푸시, HPACK
  ↓
HTTP/3 (2022) - QUIC, UDP 기반, 0-RTT

VLAN (1990s) - L2 분리
  ↓
VPN (IPsec, 1990s) - 암호화 터널
  ↓
MPLS (1990s) - 레이블 스위칭
  ↓
VXLAN (2011) - L2 over L3, 클라우드용
  ↓
SDN (2011~) - 소프트웨어 정의 네트워크
  ↓
Service Mesh (2016~) - 마이크로서비스 통신

DNS 라운드 로빈 (L3)
  ↓
L4 로드밸런서 (IP+Port)
  ↓
L7 로드밸런서 (HTTP, 애플리케이션)
  ↓
GSLB (Global Server Load Balancing)
  ↓
Service Mesh (Envoy, Istio)

SSL 2.0/3.0 (1990s) - 취약점 많음
  ↓
TLS 1.0 (1999)
  ↓
TLS 1.2 (2008) - 현재 표준
  ↓
TLS 1.3 (2018) - 1-RTT, 0-RTT, 암호화 강화

파일 시스템 (1960s)
  ↓
계층형 DB (IMS, 1960s)
  ↓
네트워크형 DB (CODASYL, 1970s)
  ↓
관계형 DB (RDBMS, 1970s~) - Oracle, MySQL, PostgreSQL
  ↓
NoSQL (2000s~) - 확장성, 유연성
  ├─ Key-Value (Redis, DynamoDB)
  ├─ Document (MongoDB, Couchbase)
  ├─ Column-Family (Cassandra, HBase)
  └─ Graph (Neo4j, Neptune)
  ↓
NewSQL (2010s~) - RDBMS + 분산 (CockroachDB, TiDB)

단일 트랜잭션
  ↓
2PL (Two-Phase Locking) - 비관적 동시성
  ↓
MVCC (Multi-Version Concurrency Control) - 낙관적, 높은 동시성
  ↓
분산 트랜잭션 (2PC, Two-Phase Commit)
  ↓
Saga Pattern (마이크로서비스 트랜잭션)

OLTP (Online Transaction Processing) - 트랜잭션, 실시간
  ↓
OLAP (Online Analytical Processing) - 분석, 집계
  ↓
HTAP (Hybrid) - OLTP + OLAP 통합
  ↓
실시간 스트림 처리 (Kafka, Flink)

단일 서버 DB
  ↓
Replication (Master-Slave)
  ↓
Clustering (Active-Active)
  ↓
Sharding (수평 분할)
  ↓
분산 합의 (Paxos, Raft)
  ↓
Multi-Region (글로벌 분산)

전통 DW (Oracle, Teradata)
  ↓
MPP (Massively Parallel Processing)
  ↓
Columnar Storage (컬럼형 저장)
  ↓
Cloud DW (Redshift, BigQuery, Snowflake)
  ↓
Lakehouse (Delta Lake, Iceberg) - DW + Data Lake

On-Premise (자체 운영)
  ↓
Hosting (서버 임대)
  ↓
IaaS (2006~) - AWS EC2, 가상 서버
  ↓
PaaS (2008~) - Heroku, GAE, 플랫폼
  ↓
CaaS (2013~) - Docker, Kubernetes, 컨테이너
  ↓
FaaS/Serverless (2014~) - Lambda, 함수

Docker Swarm (2013) - 단순
  ↓
Apache Mesos (2013)
  ↓
Kubernetes (2014) - 사실상 표준
  ↓
Managed Kubernetes (EKS, GKE, AKS)
  ↓
Serverless Kubernetes (Fargate, Cloud Run)

수동 설정
  ↓
스크립트 (Shell)
  ↓
Configuration Management (Puppet, Chef, Ansible)
  ↓
IaC (Infrastructure as Code) - Terraform, CloudFormation
  ↓
GitOps (2017~) - ArgoCD, Flux

AWS Lambda (2014) - 이벤트 기반 함수
  ↓
API Gateway + Lambda (백엔드리스)
  ↓
Step Functions (워크플로우 오케스트레이션)
  ↓
컨테이너 서버리스 (Fargate, Cloud Run)

Logging (로그 수집)
  ↓
Monitoring (지표 수집, Nagios, Zabbix)
  ↓
APM (Application Performance Monitoring, New Relic)
  ↓
분산 트레이싱 (Zipkin, Jaeger)
  ↓
통합 관찰성 (Prometheus + Grafana + Jaeger)
  ↓
OpenTelemetry (표준화, 2019~)

Waterfall (1970s) - 순차적, 문서 중심
  ↓
Spiral (1986) - 반복적, 위험 관리
  ↓
RUP (1990s) - 반복적, 아키텍처 중심
  ↓
Agile (2001) - 애자일 선언, 적응형
  ├─ XP (Extreme Programming)
  ├─ Scrum (스프린트, 일일 스탠드업)
  └─ Kanban (간판, 흐름 최적화)
  ↓
DevOps (2009~) - 개발+운영 통합
  ↓
DevSecOps (2010s~) - 보안 통합

수동 빌드+배포
  ↓
자동 빌드 (Make, Ant)
  ↓
CI (Continuous Integration) - Jenkins, 2011
  ↓
CD (Continuous Delivery) - 자동 배포 준비
  ↓
CD (Continuous Deployment) - 자동 프로덕션 배포
  ↓
GitOps (2017~) - Git 중심 배포

Manual Testing (수동)
  ↓
Unit Testing (단위 테스트)
  ↓
TDD (Test-Driven Development, 2002~)
  ↓
BDD (Behavior-Driven Development)
  ↓
Shift-Left (테스트 조기화)
  ↓
Chaos Engineering (2010s~) - 장애 주입

Monolithic (단일 애플리케이션)
  ↓
3-Tier (Presentation, Business, Data)
  ↓
SOA (Service-Oriented Architecture, 2000s)
  ↓
MSA (Microservices, 2014~) - 독립 배포, API 통신
  ↓
Serverless (FaaS)

SCCS/RCS (1970s~) - 파일 단위
  ↓
CVS (1990) - 중앙집중식
  ↓
Subversion (2000) - CVS 개선
  ↓
Git (2005) - 분산형, Linus Torvalds
  ↓
GitHub/GitLab (2008/2011) - 협업 플랫폼

AI 1차 붐 (1950s~1970s) - 기호주의, 전문가 시스템
  ↓
AI 겨울 (1970s~1980s) - 한계 직면
  ↓
AI 2차 붐 (1980s~1990s) - 전문가 시스템
  ↓
AI 겨울 (1990s~2000s)
  ↓
AI 3차 붐 (2010s~) - 딥러닝, 빅데이터, GPU

전통적 ML (1990s~)
  ├─ Decision Tree
  ├─ SVM (Support Vector Machine)
  ├─ Random Forest
  └─ Gradient Boosting (XGBoost, LightGBM)
  ↓
Deep Learning (2010s~)
  ├─ CNN (이미지, 2012 AlexNet)
  ├─ RNN/LSTM (시계열, 2014~)
  └─ Transformer (2017) - Attention Is All You Need
  ↓
Foundation Model (2020s~)
  ├─ GPT (Generative Pre-trained Transformer)
  ├─ BERT (양방향 Transformer)
  └─ Vision Transformer (ViT)

Transformer (2017, Google) - 120M params
  ↓
GPT-1 (2018, OpenAI) - 117M params
  ↓
BERT (2018, Google) - 340M params
  ↓
GPT-2 (2019) - 1.5B params
  ↓
GPT-3 (2020) - 175B params, Few-shot Learning
  ↓
ChatGPT (2022) - GPT-3.5 + RLHF
  ↓
GPT-4 (2023) - Multimodal, MoE 추정
  ↓
Claude 3 / Gemini 1.5 (2024) - 긴 컨텍스트

지도 학습 (Supervised)
  ↓
비지도 학습 (Unsupervised)
  ↓
강화 학습 (Reinforcement, AlphaGo 2016)
  ↓
Transfer Learning (전이 학습)
  ↓
Few-Shot Learning (GPT-3, 2020)
  ↓
Zero-Shot Learning
  ↓
RLHF (Reinforcement Learning from Human Feedback, 2022~)

분류 (Classification)
  ↓
객체 탐지 (Object Detection)
  ↓
이미지 생성 (GAN, 2014~)
  ↓
Text-to-Image (DALL-E, 2021 / Stable Diffusion, 2022)
  ↓
Multimodal (GPT-4V, Gemini, 2023~)

챗봇 (규칙 기반, 2010s)
  ↓
LLM 기반 대화 (ChatGPT, 2022)
  ↓
RAG (검색 증강 생성, 2023~)
  ↓
AI 에이전트 (도구 사용, 자율 행동, 2023~)
  - Function Calling, Tool Use
  - 계획 → 실행 → 관찰 루프
  ↓
멀티에이전트 시스템 (2024~)
  - 역할 분담, 협업, 토론
  - AutoGen, CrewAI, LangGraph
  ↓
Physical AI (2024~)
  - 로봇/자율시스템의 AI 제어
  - 시뮬레이션 기반 학습

대칭키 암호화
  ├─ DES (1977) - 56bit, 취약
  ├─ 3DES (1998) - 168bit
  ├─ AES (2001) - 128/192/256bit, 현재 표준
  └─ ChaCha20 (2008) - 모바일 최적화
  ↓
비대칭키 암호화
  ├─ RSA (1977) - 2048/4096bit
  ├─ ECC (1985) - 짧은 키, 모바일
  └─ 양자내성 암호 (Post-Quantum, 2024 NIST 표준 확정: FIPS 203 ML-KEM, FIPS 204 ML-DSA, FIPS 205 SLH-DSA)

Password (단순 비밀번호)
  ↓
Hashing (MD5 → SHA-1 → SHA-256)
  ↓
Salt + Hash (Rainbow Table 방어)
  ↓
Key Stretching (bcrypt, scrypt, Argon2)
  ↓
2FA (Two-Factor Authentication)
  ↓
MFA (Multi-Factor Authentication)
  ↓
Passkey (FIDO2, 2022~) - 비밀번호 없는 인증

Firewall (1980s~) - 패킷 필터링
  ↓
IDS (Intrusion Detection System, 1990s) - 탐지
  ↓
IPS (Intrusion Prevention System) - 차단
  ↓
WAF (Web Application Firewall) - L7 보호
  ↓
NGFW (Next-Generation Firewall) - 애플리케이션 인식
  ↓
Zero Trust (2010s~) - "절대 신뢰하지 않고 항상 검증"

전통적 Perimeter Security (경계 보안)
  ↓
IAM (Identity and Access Management)
  ↓
CASB (Cloud Access Security Broker)
  ↓
CSPM (Cloud Security Posture Management)
  ↓
SASE (Secure Access Service Edge)
  ↓
Zero Trust Network Access (ZTNA)

배열 (Array, 1960s) - 연속 메모리, O(1) 접근
  ↓
동적 배열 (Dynamic Array, 1970s) - 가변 크기 (ArrayList, Vector)
  ↓
연결 리스트 (Linked List, 1960s) - 포인터 연결, 동적 메모리
  ├─ 단방향 (Singly)
  ├─ 양방향 (Doubly)
  └─ 환형 (Circular)
  ↓
Skip List (1990) - O(log n) 검색, 확률적 균형

스택 (Stack, 1946) - LIFO, 함수 호출, 후위 표기식
  ↓
큐 (Queue, 1960s) - FIFO, 스케줄링, BFS
  ↓
덱 (Deque) - 양방향 삽입/삭제
  ↓
우선순위 큐 (Priority Queue) - 힙 기반, 다익스트라
  ↓
Concurrent Queue (2000s~) - Lock-Free, CAS

이진 트리 (Binary Tree, 1960s)
  ↓
BST (Binary Search Tree) - O(log n) 검색 (균형 시)
  ↓
균형 트리 (1960s~1970s)
  ├─ AVL Tree (1962) - 엄격 균형, 회전
  ├─ Red-Black Tree (1972) - 느슨한 균형, 빠른 삽입
  └─ B-Tree (1972) - 디스크 I/O 최적화, DB 인덱스
  ↓
B+Tree (1973) - 리프 노드 연결, 범위 쿼리
  ↓
Trie (1960) - 문자열 검색, 자동완성
  ↓
LSM Tree (1996) - 쓰기 최적화, NoSQL (Cassandra, LevelDB)

해시 테이블 (1953) - O(1) 평균 접근
  ↓
체이닝 (Chaining) - 충돌 해결, 연결 리스트
  ↓
개방 주소법 (Open Addressing) - 선형/이차/이중 해싱
  ↓
동적 해싱 (Dynamic Hashing) - 확장 가능
  ↓
Consistent Hashing (1997) - 분산 시스템, 캐시
  ↓
Cuckoo Hashing (2001) - 최악 O(1) 보장

인접 행렬 (Adjacency Matrix) - O(V²) 공간, O(1) 간선 확인
  vs
인접 리스트 (Adjacency List) - O(V+E) 공간, 희소 그래프

Heap (1964) - 우선순위 큐, O(log n)
  ├─ Binary Heap
  ├─ Fibonacci Heap (1984) - 빠른 decrease-key
  └─ Pairing Heap
  ↓
Disjoint Set (Union-Find, 1964) - 집합 관리, Kruskal
  ↓
Segment Tree (1977) - 구간 쿼리, O(log n)
  ↓
Fenwick Tree (BIT, 1994) - 구간 합, 메모리 효율

Blocking Queue (초기)
  ↓
Lock-Free Queue (2000s) - CAS 기반
  ↓
Work-Stealing Queue (2000s) - ForkJoinPool

단순 정렬 (1950s~) - O(n²)
  ├─ Bubble Sort (교환, 안정)
  ├─ Selection Sort (선택, 불안정)
  └─ Insertion Sort (삽입, 안정, 거의 정렬된 데이터에 빠름)
  ↓
분할정복 정렬 (1960s~) - O(n log n)
  ├─ Merge Sort (1945) - 안정, O(n) 공간
  ├─ Quick Sort (1960) - 불안정, 평균 빠름, 최악 O(n²)
  └─ Heap Sort (1964) - 불안정, O(1) 공간
  ↓
특수 정렬
  ├─ Counting Sort (1954) - O(n+k), 정수, 안정
  ├─ Radix Sort (1954) - O(d×n), 자릿수
  └─ Bucket Sort - O(n+k), 균등 분포
  ↓
하이브리드 정렬
  ├─ Introsort (1997) - Quick + Heap, C++ std::sort
  └─ Timsort (2002) - Merge + Insertion, Python/Java

순차 탐색 (Linear Search) - O(n)
  ↓
이진 탐색 (Binary Search, 1946) - O(log n), 정렬 필요
  ↓
보간 탐색 (Interpolation Search) - O(log log n), 균등 분포
  ↓
해시 탐색 (Hash Search) - O(1) 평균
  ↓
트리 탐색 (BST, B-Tree) - O(log n)

DFS (Depth-First Search, 1950s) - 스택/재귀, 경로 탐색
  ↓
BFS (Breadth-First Search, 1959) - 큐, 최단 경로
  ↓
Dijkstra (1956) - 단일 출발 최단 경로, O((V+E) log V)
  ↓
Bellman-Ford (1958) - 음수 가중치 허용, O(VE)
  ↓
Floyd-Warshall (1962) - 모든 쌍 최단 경로, O(V³)
  ↓
A* (1968) - 휴리스틱 기반, 게임/경로 찾기
  ↓
Bidirectional Search (양방향 탐색)

분할 정복 (Divide and Conquer)
  - Merge Sort, Quick Sort, 이진 탐색, FFT
  ↓
동적 프로그래밍 (Dynamic Programming, 1950s)
  - 피보나치, 배낭 문제, LCS, Memoization
  ↓
탐욕 알고리즘 (Greedy, 1950s)
  - Dijkstra, Kruskal, Prim, Huffman 코딩
  ↓
백트래킹 (Backtracking)
  - N-Queen, 미로, 부분집합

브루트 포스 (O(nm))
  ↓
KMP (1977) - O(n+m), 실패 함수
  ↓
Boyer-Moore (1977) - O(n/m) 최선, Bad Character
  ↓
Rabin-Karp (1987) - O(n+m) 평균, 해싱
  ↓
Aho-Corasick (1975) - 다중 패턴, Trie 기반

Kruskal (1956) - 간선 정렬, Union-Find, O(E log E)
  vs
Prim (1957) - 정점 확장, 우선순위 큐, O(E log V)

Ford-Fulkerson (1956) - 최대 유량
  ↓
Edmonds-Karp (1972) - BFS, O(VE²)
  ↓
Dinic (1970) - Level Graph, O(V²E)

NP-완전 문제 (1971)
  ↓
근사 알고리즘 (1970s~) - TSP, Vertex Cover
  ↓
휴리스틱 (Heuristic) - 빠른 근사해
  ↓
메타 휴리스틱 (1980s~)
  ├─ Simulated Annealing (1983)
  ├─ Genetic Algorithm (1975)
  └─ Ant Colony Optimization (1992)

Monolithic (1960s~) - 단일 배포 단위, 간단, 확장 어려움
  ↓
Layered Architecture (1970s~) - Presentation, Business, Data
  ↓
Client-Server (1980s) - 2-Tier, 3-Tier
  ↓
MVC (1979) - Model, View, Controller 분리
  ↓
SOA (Service-Oriented, 2000s) - SOAP, ESB, 재사용
  ↓
MSA (Microservices, 2014~) - 독립 배포, REST/gRPC, 폴리글랏
  ↓
Serverless (FaaS, 2014~) - 이벤트 기반, 자동 스케일링

동기 호출 (Synchronous Call) - 직접 호출, 강결합
  ↓
비동기 메시징 (Asynchronous Messaging)
  ├─ Message Queue (1980s~) - MQ, RabbitMQ
  ├─ Pub/Sub (1990s~) - 토픽 기반, Kafka
  └─ Event Streaming (2010s~) - 이벤트 소싱, CQRS
  ↓
Event-Driven Architecture (EDA, 2000s~) - 느슨한 결합
  ↓
Event Sourcing + CQRS (2010s~) - 이벤트 저장, 읽기/쓰기 분리

중앙집중식 DB (1970s~) - 단일 데이터베이스
  ↓
레플리케이션 (Replication) - Master-Slave
  ↓
샤딩 (Sharding) - 수평 분할
  ↓
분산 데이터베이스 (2000s~) - NoSQL, 분산 합의
  ↓
폴리글랏 퍼시스턴스 (2010s~) - 용도별 DB 선택
  ↓
Data Mesh (2019~) - 도메인 중심 데이터 소유권

직접 통합 (Point-to-Point) - n(n-1)/2 연결
  ↓
ESB (Enterprise Service Bus, 2000s) - 중앙 통합, 병목
  ↓
API Gateway (2010s~) - 단일 진입점, 라우팅, 인증
  ↓
Service Mesh (2016~) - 사이드카, 트래픽 관리 (Istio, Linkerd)

수직 확장 (Vertical Scaling) - Scale-Up, 한계 존재
  ↓
수평 확장 (Horizontal Scaling) - Scale-Out, 무한 확장
  ↓
Auto Scaling (2000s~) - 부하 기반 자동 확장
  ↓
Elastic Scaling (클라우드) - 즉각 확장/축소

Retry (재시도) - 단순 재시도, 지수 백오프
  ↓
Circuit Breaker (2007) - 장애 전파 차단, Hystrix
  ↓
Bulkhead (격벽) - 리소스 격리
  ↓
Rate Limiting (속도 제한) - Token Bucket, Leaky Bucket
  ↓
Chaos Engineering (2010s~) - 장애 주입, Netflix

SWOT 분석 (1960s) - 강점/약점/기회/위협
  ↓
Porter의 5 Forces (1979) - 산업 구조 분석
  ↓
가치사슬 (Value Chain, 1985) - 본원 활동, 지원 활동
  ↓
핵심역량 (Core Competence, 1990) - 경쟁우위 원천
  ↓
블루오션 전략 (2005) - 비경쟁 시장 창출
  ↓
린 스타트업 (2011) - MVP, Build-Measure-Learn

전략적 정렬 모델 (Strategic Alignment, 1993)
  - 비즈니스 전략 ↔ IT 전략 정렬
  ↓
EA (Enterprise Architecture, 1987~)
  ├─ Zachman Framework (1987)
  ├─ TOGAF (1995)
  └─ Federal EA (1999)
  ↓
IT 거버넌스 (2000s~)
  ├─ COBIT (1996)
  ├─ ITIL (1989)
  └─ ISO 20000
  ↓
디지털 전환 (Digital Transformation, 2010s~)

재무 지표 (1900s~) - ROI, 매출, 이익
  ↓
BSC (Balanced Scorecard, 1992) - 4가지 관점 균형
  ├─ 재무 (Financial)
  ├─ 고객 (Customer)
  ├─ 내부 프로세스 (Internal Process)
  └─ 학습과 성장 (Learning & Growth)
  ↓
KPI (Key Performance Indicator, 1990s~) - 핵심 지표
  ↓
OKR (Objectives and Key Results, 1970s/2010s~)
  - Objective(목표) + Key Results(핵심 결과)
  - Google, Intel 사용
  ↓
North Star Metric (2010s~) - 단일 핵심 지표

Waterfall (1970s) - 순차적, 문서 중심
  ↓
Spiral (1986) - 반복적, 위험 관리
  ↓
RUP (1990s) - 반복적, 아키텍처 중심
  ↓
Agile (2001) - 애자일 선언
  ├─ Scrum (1995) - 스프린트, 일일 스크럼
  ├─ XP (1996) - TDD, 페어 프로그래밍
  └─ Kanban (2000s) - 흐름 최적화, WIP 제한
  ↓
SAFe (Scaled Agile, 2011) - 대규모 애자일

전통적 비즈니스 모델 (제품 판매)
  ↓
구독 모델 (Subscription, 2000s~) - SaaS, Netflix
  ↓
프리미엄 (Freemium, 2006) - 기본 무료, 프리미엄 유료
  ↓
플랫폼 비즈니스 (2010s~) - 양면 시장, 네트워크 효과
  ↓
공유 경제 (Sharing Economy, 2010s~) - Airbnb, Uber
  ↓
API 이코노미 (2010s~) - API as a Product

디지타이제이션 (Digitization) - 아날로그 → 디지털 변환
  ↓
디지털라이제이션 (Digitalization) - 프로세스 디지털화
  ↓
디지털 트랜스포메이션 (Digital Transformation)
  - 비즈니스 모델/문화/조직 혁신
  ↓
AI 트랜스포메이션 (2020s~) - AI 중심 혁신

비트코인 (2009) - PoW, 퍼블릭, 7 TPS
  ↓
이더리움 (2015) - 스마트 컨트랙트, Solidity
  ↓
프라이빗/컨소시엄 체인 (2015~)
  ├─ Hyperledger Fabric (2016) - PBFT, 허가형
  └─ Corda (2016) - 금융 특화
  ↓
이더리움 2.0 (2022) - PoS, 샤딩, 확장성 개선
  ↓
레이어2 (2020s~) - 롤업(Optimistic/ZK), 사이드체인
  ↓
토큰 경제 (2020s~)
  ├─ NFT (2017~) - 디지털 자산 소유권, ERC-721
  ├─ DeFi (2020~) - 탈중앙 금융, DEX, 대출
  ├─ CBDC (2020s~) - 중앙은행 디지털 화폐
  ├─ STO (Security Token Offering) - 증권형 토큰
  └─ RWA 토큰화 (2023~) - 실물자산 토큰화

M2M (Machine-to-Machine, 2000s) - 단순 연결
  ↓
IoT (Internet of Things, 2010s~)
  - 센서, 액추에이터, 게이트웨이, 클라우드
  ↓
프로토콜 발전
  ├─ MQTT (1999) - 경량 Pub/Sub
  ├─ CoAP (2010) - 제약 장치용 HTTP
  └─ LoRaWAN (2015) - 저전력 장거리
  ↓
Edge Computing (2016~) - 엣지에서 처리, 저지연
  ↓
Digital Twin (2010s~) - 물리적 객체의 디지털 복제
  ↓
IoB (Internet of Behavior, 2020s~) - 행동 데이터 수집

양자역학 이론 (1920s)
  ↓
Shor's Algorithm (1994) - RSA 암호 해독 알고리즘
  ↓
Grover's Algorithm (1996) - 탐색 속도 향상
  ↓
초기 양자 컴퓨터 (2000s~) - 수십 큐비트
  ↓
양자 우위 (Quantum Supremacy, 2019) - Google 53큐비트
  ↓
실용적 양자 컴퓨터 (2020s~)
  ├─ IBM (2023, 433큐비트)
  ├─ Google (Willow, 2024)
  └─ Amazon Braket
  ↓
양자 내성 암호 (Post-Quantum Cryptography) - NIST 표준화

VR (Virtual Reality, 1960s~)
  - 완전 몰입, HMD, Oculus (2012)
  ↓
AR (Augmented Reality, 1990s~)
  - 현실 + 가상, Pokemon GO (2016), ARKit/ARCore
  ↓
MR (Mixed Reality, 2010s~)
  - 가상↔현실 상호작용, HoloLens (2016)
  ↓
XR (Extended Reality) - VR+AR+MR 통칭
  ↓
메타버스 (Metaverse, 2020s~)
  - 3D 가상세계, 경제 활동, Roblox, Fortnite
  ↓
Spatial Computing (2020s~) - Vision Pro (2024)

전통 금융 (오프라인, 지점 중심)
  ↓
인터넷뱅킹 (2000s) - 온라인 계좌 조회/이체
  ↓
핀테크 (FinTech, 2010s~) - 기술 + 금융 결합
  ├─ 간편결제 (2013~) - Apple Pay, 카카오페이
  ├─ P2P 대출 (2015~)
  └─ 로보어드바이저 (2016~)
  ↓
오픈뱅킹 (2019~) - API 기반 금융 데이터 공유
  ↓
마이데이터 (2022~) - 개인 금융정보 자기결정권
  ↓
임베디드 금융 (Embedded Finance, 2020s~)
  - 비금융 서비스에 금융 기능 내장
  - BaaS (Banking as a Service)
  ↓
RegTech (2020s~) - 규제 준수 자동화, AI 기반 이상탐지

클라우드 중심 (2010s) - 중앙 집중 처리
  ↓
Fog Computing (2012) - 중간 계층 처리
  ↓
Edge Computing (2016~) - 엣지 디바이스에서 처리
  ├─ MEC (Multi-access Edge Computing)
  └─ Cloudlet (소규모 데이터센터)
  ↓
Far Edge (2020s~) - 디바이스 자체에서 처리 (AI 칩)

1G (1980s) - 아날로그 음성
  ↓
2G (1991) - 디지털 음성, SMS
  ↓
3G (1998) - 모바일 인터넷
  ↓
4G LTE (2009) - 고속 데이터, 100Mbps
  ↓
5G (2019) - 초저지연(1ms), 초고속(10Gbps), 초연결
  - eMBB (광대역), URLLC (저지연), mMTC (대규모 연결)
  ↓
6G (2030 예상) - 테라헤르츠파, 100Gbps, 홀로그램

전통적 IT (에너지 소비 무관심)
  ↓
Green IT (2007~) - 에너지 효율, 전자 폐기물 감소
  ↓
탄소 중립 (Carbon Neutral, 2010s~) - 탄소 배출 상쇄
  ↓
Carbon-Aware Computing (2020s~)
  - 탄소 배출 낮은 시간/지역에서 워크로드 실행
  ↓
Sustainable IT (지속가능 IT)
  - ESG, 순환 경제, 재생 에너지

Docker (이미지) → Kubernetes (오케스트레이션) → Helm (패키지 관리)
  + Service Mesh (Istio/Linkerd)
  + GitOps (ArgoCD)
  + 관찰성 (Prometheus + Grafana + Jaeger)

API Gateway → 인증/인가 → 서비스 디스커버리 → 로드밸런싱
  → Circuit Breaker → 분산 트레이싱 → 로깅 → 모니터링

수집 (Kafka) → 처리 (Spark/Flink) → 저장 (Data Lake/DW)
  → 분석 (Presto/Athena) → 시각화 (Tableau/Superset)

코드 (Git) → 빌드 (Maven/Gradle) → CI (Jenkins/GitHub Actions)
  → 테스트 (JUnit/Jest) → CD (ArgoCD/Spinnaker)
  → 모니터링 (Prometheus/Grafana)

데이터 수집 → 전처리 (Feature Store) → 학습 (MLflow)
  → 모델 레지스트리 → 배포 (Seldon/KServe)
  → 모니터링 (Drift Detection)

개인정보보호 개별법 (2000s~)
  ├─ 정보통신망법 (2001)
  ├─ 신용정보법 (2001)
  └─ 위치정보법 (2005)
  ↓
개인정보보호법 제정 (2011) - 일반법
  ↓
개정 강화 (2020)
  - 데이터 3법 (가명정보, 개인정보위 출범)
  - 가명처리, 결합 허용
  ↓
GDPR 정합성 (2021~)
  - EU 적정성 결정
  - 국외 이전 규정 강화
  ↓
전면 개정 (2023, 2024.3 시행)
  - 과징금 전체 매출 3%로 상향
  - 국외이전 규정 개선
  - 자동화된 의사결정 대응권 신설

정보보호관리체계 (ISMS, 2001)
  - 정보보호 관리 체계 인증
  ↓
PIMS (2010)
  - 개인정보보호 관리 체계
  ↓
ISMS-P (2018)
  - ISMS + PIMS 통합
  - 정보보호 + 개인정보보호
  ↓
인증기준 개정 (2023)
  - 통제항목 104개 → 80개(관리체계 16 + 보호대책 64)
  - ISMS-P: 102개(관리체계 16 + 보호대책 64 + 개인정보 22)
  ↓
인증 범위 확대 (2020s~)
  - 클라우드 보안인증 (CSAP)
  - IoT 보안인증

ISO/IEC 27001 (2005) - 정보보안 관리체계
  ↓
ISO/IEC 27002 (2005) - 실행 지침
  ↓
ISO/IEC 27017 (2015) - 클라우드 보안
  ↓
ISO/IEC 27018 (2014) - 클라우드 개인정보
  ↓
ISO/IEC 27701 (2019) - 개인정보 관리체계 (PIMS)

전자정부법 (2001)
  ↓
전자정부 표준프레임워크 (2009)
  - 표준화된 개발 환경
  ↓
공공 클라우드 전환 (2010s~)
  - 클라우드컴퓨팅법 (2015)
  - G-Cloud
  ↓
디지털정부법 (2020)
  - 데이터 기반 행정
  - 마이데이터

CMM (1991) - 성숙도 모델
  ↓
CMMI (2000) - 통합 성숙도 모델
  ├─ CMMI-DEV (개발)
  ├─ CMMI-SVC (서비스)
  └─ CMMI-ACQ (획득)
  ↓
ISO/IEC 25010:2011 (SQuaRE)
  - 소프트웨어 품질 모델 (8개 특성)
  - 기능 적합성, 성능 효율성, 호환성, 사용성, 신뢰성, 보안성, 유지보수성, 이식성
  ↓
ISO/IEC 25010:2023 (개정)
  - 안전성(Safety) 추가 → 9개 특성

RDBMS (1990s~) - 정형 데이터, 수직 확장 한계
  ↓
Hadoop Ecosystem (2006~)
  ├─ HDFS (분산 저장)
  ├─ MapReduce (배치 처리)
  └─ Hive (SQL on Hadoop)
  ↓
Spark (2014~)
  - In-Memory 처리
  - 10~100배 빠름
  - Spark SQL, Spark Streaming
  ↓
Flink (2016~)
  - True Streaming (이벤트 단위)
  - Exactly-once 보장
  ↓
Lakehouse (2020s~)
  - Delta Lake, Iceberg, Hudi
  - DW + Data Lake 통합

Lucene (1999) - 검색 라이브러리
  ↓
Solr (2004) - 검색 서버
  - 풀텍스트 검색
  ↓
Elasticsearch (2010)
  - 분산 검색 엔진
  - RESTful API
  - ELK Stack (Elastic + Logstash + Kibana)
  ↓
Vector DB (2020s~)
  ├─ Pinecone (2021)
  ├─ Milvus (2021)
  ├─ Weaviate (2022)
  └─ Chroma (2022)
  - 임베딩 벡터 검색
  - RAG, 추천시스템

메시지 큐 (2000s~)
  ├─ ActiveMQ (2004)
  └─ RabbitMQ (2007)
  ↓
Kafka (2011)
  - 분산 로그 시스템
  - 높은 처리량, 내구성
  ↓
Kafka Ecosystem (2015~)
  ├─ Kafka Streams (스트림 처리)
  ├─ ksqlDB (스트리밍 SQL)
  └─ Kafka Connect (연동)
  ↓
Pulsar (2016, Yahoo→Apache)
  - 멀티테넌시
  - Geo-Replication

수동 데이터 관리 (2000s~)
  ↓
마스터 데이터 관리 (MDM, 2000s)
  - 핵심 데이터 표준화
  ↓
데이터 카탈로그 (2010s~)
  - Alation, Collibra
  - 메타데이터 관리
  ↓
Data Fabric (2020s~, Gartner)
  - 메타데이터 기반 자동 통합
  - 중앙 관리, AI/ML 활용
  ↓
Data Mesh (2019~, Zhamak Dehghani)
  - 도메인 중심 데이터 소유권
  - Data as a Product
  - 셀프서비스 플랫폼
  ↓
DataOps (2020s~)
  - 데이터 파이프라인 자동화
  - 데이터 품질 모니터링

컴퓨터구조: 멀티코어, NUMA
  ↔ DB: 샤딩, 레플리케이션, CAP
  ↔ 클라우드: Scale-Out, Auto Scaling
  ↔ 아키텍처: MSA, 무상태

컴퓨터구조: L1/L2/L3 캐시, TLB
  ↔ DB: 버퍼 캐시, 쿼리 캐시
  ↔ 네트워크: CDN, 프록시 캐시
  ↔ 아키텍처: Redis, Memcached
  ↔ 웹: HTTP 캐시, 브라우저 캐시

DB: ACID, 2PC, MVCC
  ↔ 분산시스템: Saga, 보상 트랜잭션
  ↔ 블록체인: 스마트 컨트랙트
  ↔ MSA: 이벤트 소싱, 최종 일관성

네트워크: TLS, IPSec, VPN
  ↔ 암호학: 대칭키, 비대칭키, 해시
  ↔ 인증: OAuth, SAML, FIDO
  ↔ 법제도: 개인정보보호법, ISMS
  ↔ 아키텍처: Zero Trust, mTLS

알고리즘: 그래프, 최적화
  ↔ 데이터: 전처리, 피처 엔지니어링
  ↔ 인프라: GPU, TPU, 분산 학습
  ↔ 운영: MLOps, 모델 서빙
  ↔ 법제도: AI 윤리, 설명가능 AI

정적 HTML (1990s)
  - 서버에서 완성된 HTML 전송
  ↓
JavaScript + DOM 조작 (1995~)
  - 동적 웹페이지
  - document.getElementById()
  ↓
jQuery (2006~)
  - DOM 조작 단순화
  - $() 셀렉터, 크로스브라우저
  - 플러그인 생태계
  ↓
Backbone.js / Ember.js (2010~)
  - MVC 패턴 도입
  - 구조화된 코드
  ↓
AngularJS (2010~)
  - 양방향 데이터 바인딩
  - 의존성 주입
  - Google 지원
  ↓
React (2013~, Facebook)
  - Virtual DOM
  - 컴포넌트 기반
  - 단방향 데이터 흐름
  - JSX
  ↓
Angular 2+ (2016~)
  - TypeScript 기반
  - 완전 재작성
  - RxJS 반응형
  ↓
Vue.js (2014~)
  - Progressive Framework
  - 쉬운 학습 곡선
  - 양방향 바인딩 + Virtual DOM
  ↓
Svelte (2016~)
  - 컴파일 타임 처리
  - No Virtual DOM
  - 최소 번들 크기
  ↓
Next.js/Nuxt.js (2016~)
  - SSR + SSG
  - 파일 기반 라우팅
  - 풀스택 프레임워크화
  ↓
React Server Components (2020~)
  - 서버 컴포넌트
  - 하이브리드 렌더링

jQuery (전역 변수/이벤트)
  ↓
Flux (2014, Facebook)
  - 단방향 데이터 흐름
  - Action → Dispatcher → Store → View
  ↓
Redux (2015)
  - 단일 Store
  - 불변성
  - Pure Function Reducer
  ↓
MobX (2015)
  - Observable 패턴
  - 자동 추적
  - 덜 보일러플레이트
  ↓
Context API (React 16.3, 2018)
  - 내장 상태 공유
  - Provider/Consumer
  ↓
Zustand / Jotai / Recoil (2020~)
  - 경량 상태 관리
  - Hooks 기반
  - 원자적 상태
  ↓
TanStack Query (React Query, 2020~)
  - 서버 상태 관리
  - 캐싱, 동기화
  - Stale-While-Revalidate

CSR (Client-Side Rendering)
  - 브라우저에서 렌더링
  - SPA, 초기 로딩 느림
  ↓
SSR (Server-Side Rendering)
  - 서버에서 HTML 생성
  - SEO 개선, TTFB 개선
  ↓
SSG (Static Site Generation)
  - 빌드 타임에 HTML 생성
  - CDN 배포, 최고 성능
  ↓
ISR (Incremental Static Regeneration)
  - 정적 + 동적 결합
  - 백그라운드 재생성
  - Next.js 도입
  ↓
Streaming SSR + React Server Components
  - 점진적 HTML 전송
  - 서버/클라이언트 컴포넌트 분리

수동 관리 (1990s~)
  - 콘솔 클릭
  - 문서화된 수동 절차
  - 휴먼 에러 빈번
  ↓
쉘 스크립트 (2000s)
  - Bash, PowerShell
  - 반복 작업 자동화
  - 멱등성 없음
  ↓
CFEngine (1993)
  - 최초의 구성 관리 도구
  - 선언적 언어
  ↓
Puppet (2005)
  - Ruby DSL
  - 에이전트 기반
  - 엔터프라이즈 구성 관리
  ↓
Chef (2009)
  - Ruby 기반 DSL
  - "Recipe", "Cookbook"
  - 절차적 접근
  ↓
Ansible (2012, Red Hat)
  - YAML 기반
  - 에이전트리스 (SSH)
  - 쉬운 학습 곡선
  - 멱등성 보장
  ↓
SaltStack (2011)
  - 이벤트 기반
  - 빠른 실행 속도
  ↓
Docker (2013)
  - 컨테이너 이미지
  - Dockerfile
  - 불변 인프라
  ↓
Terraform (2014, HashiCorp)
  - HCL (선언형)
  - 멀티 클라우드
  - State 관리
  - Plan → Apply
  ↓
CloudFormation (AWS)
  - AWS 네이티브 IaC
  - YAML/JSON
  ↓
Kubernetes (2014)
  - 선언적 YAML
  - 컨테이너 오케스트레이션
  - Desired State 관리
  ↓
Pulumi (2018)
  - 일반 프로그래밍 언어
  - Python, TypeScript, Go
  - 조건문, 반복문 사용 가능
  ↓
CDK (AWS, 2019)
  - 프로그래밍 언어로 CloudFormation 생성
  - TypeScript, Python
  ↓
Crossplane (2018~)
  - K8s 기반 인프라 관리
  - CRD로 클라우드 리소스 정의
  ↓
OpenTofu (2023~)
  - Terraform 포크 (오픈소스)
  - BSL 라이선스 대응

선언형 (Declarative)           절차형 (Imperative)
┌─────────────────────┐       ┌─────────────────────┐
│ "무엇을" 원하는지    │       │ "어떻게" 할지       │
│ 정의                │       │ 단계별 명령         │
├─────────────────────┤       ├─────────────────────┤
│ Terraform           │       │ Ansible (일부)      │
│ CloudFormation      │       │ Shell Script        │
│ Kubernetes YAML     │       │ Chef (일부)         │
│ Pulumi              │       │                     │
└─────────────────────┘       └─────────────────────┘

장점: 멱등성, 상태 관리        장점: 유연성, 디버깅 용이
단점: 복잡한 로직 어려움       단점: 드리프트 발생 가능

시스템 모니터링 (1990s~)
  - CPU, Memory, Disk 사용률
  - SNMP, Nagios, Zabbix
  - 임계값 기반 알림
  ↓
APM 등장 (2000s)
  - Application Performance Management
  - 트랜잭션 추적
  - New Relic, AppDynamics, Dynatrace
  ↓
로그 집계 (2010s)
  - 중앙화된 로그 관리
  - ELK Stack (Elasticsearch + Logstash + Kibana)
  - Splunk
  ↓
시계열 메트릭 (2012~)
  - Graphite, InfluxDB
  - 시계열 데이터베이스
  - 대시보드 시각화
  ↓
Prometheus (2012~, SoundCloud)
  - Pull 기반 메트릭 수집
  - PromQL
  - Kubernetes 네이티브
  - Alertmanager
  ↓
분산 트레이싱 (2010s~)
  - Google Dapper 논문 (2010)
  - Zipkin (2012, Twitter)
  - Jaeger (2017, Uber)
  - 마이크로서비스 추적
  ↓
Observability 3요소 통합 (2018~)
  - Metrics + Logs + Traces
  - 상관관계 분석
  - Datadog, Grafana Cloud
  ↓
OpenTelemetry (2019~)
  - OpenTracing + OpenCensus 통합
  - 벤더 중립 표준
  - 자동 계측 (Auto-instrumentation)
  ↓
Grafana 스택 (2020s)
  - Prometheus (Metrics)
  - Loki (Logs)
  - Tempo (Traces)
  - 통합 대시보드
  ↓
eBPF 기반 관측 (2020s~)
  - 커널 레벨 관측
  - 무에이전트 계측
  - Cilium, Pixie, Falco

       ┌────────────────────────────────────────┐
       │            Correlation                 │
       │   (Trace ID로 연결)                    │
       └────────────────────────────────────────┘
              │           │           │
              ▼           ▼           ▼
       ┌──────────┐ ┌──────────┐ ┌──────────┐
       │ Metrics  │ │  Logs    │ │  Traces  │
       │ (집계)   │ │ (이벤트) │ │ (흐름)   │
       ├──────────┤ ├──────────┤ ├──────────┤
       │Prometheus│ │ Loki/ELK │ │ Jaeger   │
       │Datadog   │ │ Splunk   │ │ Zipkin   │
       │CloudWatch│ │CloudWatch│ │ X-Ray    │
       └──────────┘ └──────────┘ └──────────┘
            │            │            │
            └────────────┴────────────┘
                         │
                         ▼
                  ┌──────────────┐
                  │   Grafana    │
                  │   (통합 UI)   │
                  └──────────────┘

질문 예시:
- "에러율이 왜 올랐지?" → Metrics 확인
- "어떤 에러가 발생했지?" → Logs 확인
- "요청이 어디서 느려졌지?" → Traces 확인

임계값 알림 (전통)
  - CPU > 80% → 알림
  - 노이즈 많음, 컨텍스트 부족
  ↓
이상 탐지 (Anomaly Detection)
  - 통계적 기준선 대비
  - 동적 임계값
  ↓
SLO 기반 알림
  - Error Budget 소진 시 알림
  - 비즈니스 영향 중심
  ↓
AIOps
  - ML 기반 이상 탐지
  - 자동 상관관계 분석
  - 노이즈 감소

배열 (Array) - 연속 메모리, O(1) 접근
  ↓
연결 리스트 (Linked List) - 동적 메모리, O(1) 삽입/삭제
  ↓
이중 연결 리스트 (Doubly Linked List) - 양방향 탐색

스택 (Stack) - LIFO
  ↓
큐 (Queue) - FIFO
  ↓
덱 (Deque) - 양방향 삽입/삭제
  ↓
우선순위 큐 (Priority Queue) - 힙 기반, O(log n)

이진 트리 (Binary Tree)
  ↓
BST (Binary Search Tree) - O(log n) 평균
  ↓
AVL Tree (1962) - 엄격 균형, 높이 차 ≤ 1
  ↓
Red-Black Tree (1972) - 느슨한 균형, 삽입/삭제 빠름
  ↓
B-Tree (1972) - 디스크 I/O 최적화, DB 인덱스
  ↓
B+ Tree (1973) - 리프 연결, 범위 쿼리 최적화
  ↓
LSM Tree (1996) - 쓰기 최적화, NoSQL (Cassandra, RocksDB)

해시 테이블 (1953) - O(1) 평균 접근
  ↓
체이닝 (Chaining) - 충돌 해결, 연결 리스트
  ↓
개방 주소법 (Open Addressing) - 선형/이차/이중 해싱
  ↓
Cuckoo Hashing (2001) - 최악 O(1) 조회 보장
  ↓
분산 해시: Consistent Hashing (1997) → DHT (Distributed Hash Table)

Trie (1960) - 문자열 검색, 자동완성, O(m)
  ↓
Radix Tree (Compressed Trie) - 메모리 절약, 공통 접두사 압축
  ↓
Suffix Tree (1973) - 모든 접미사 인덱싱, 패턴 매칭

완전 탐색 (Brute Force) - 모든 경우 확인
  ↓
백트래킹 (Backtracking) - 가지치기, 불필요한 탐색 제거
  ↓
그리디 (Greedy) - 지역 최적해, Dijkstra/Huffman
  ↓
분할 정복 (Divide and Conquer) - 문제 분할, Merge Sort/FFT
  ↓
동적 프로그래밍 (Dynamic Programming) - 중복 부분문제, 최적 부분구조
  ↓
메타휴리스틱 (Meta-Heuristic)
  ├─ 유전 알고리즘 (Genetic Algorithm, 1975)
  ├─ 시뮬레이티드 어닐링 (SA, 1983)
  └─ 개미 군집 최적화 (ACO, 1992)

1세대: O(n²)
  ├─ 버블 정렬 (Bubble Sort) - 교환, 안정
  ├─ 삽입 정렬 (Insertion Sort) - 안정, 거의 정렬 시 빠름
  └─ 선택 정렬 (Selection Sort) - 불안정
  ↓
2세대: O(n log n)
  ├─ 머지 정렬 (Merge Sort) - 안정, O(n) 공간
  ├─ 퀵 정렬 (Quick Sort) - 평균 최빠름, 최악 O(n²)
  └─ 힙 정렬 (Heap Sort) - O(1) 공간
  ↓
3세대: O(n) 특수 정렬
  ├─ 기수 정렬 (Radix Sort) - O(d×n), 자릿수
  └─ 계수 정렬 (Counting Sort) - O(n+k), 정수
  ↓
4세대: 하이브리드
  └─ TimSort (2002) - Merge + Insertion, Python/Java 표준

Dijkstra (1956) - 단일 출발, 양수 가중치, O((V+E) log V)
  ↓
Bellman-Ford (1958) - 음수 가중치 허용, O(VE)
  ↓
Floyd-Warshall (1962) - 모든 쌍, O(V³)
  ↓
A* (1968) - 휴리스틱 기반, 경로 탐색 최적화

브루트 포스 (Brute Force) - O(nm), 단순 비교
  ↓
KMP (1977) - O(n+m), 실패 함수, 접두사 활용
  ↓
Boyer-Moore (1977) - O(n/m) 최선, Bad Character Rule
  ↓
Rabin-Karp (1987) - O(n+m) 평균, 롤링 해시
  ↓
Aho-Corasick (1975) - 다중 패턴 동시 매칭, Trie + BFS

모놀리식 (Monolithic) - 단일 배포, 단순
  ↓
2-Tier (Client-Server) - 프레젠테이션/데이터 분리
  ↓
3-Tier / N-Tier - Presentation/Business/Data 분리
  ↓
SOA (Service-Oriented, 2000s) - SOAP, ESB, 서비스 재사용
  ↓
MSA (Microservices, 2014~) - 독립 배포, API Gateway, 폴리글랏
  ↓
서버리스 (Serverless/FaaS, 2014~) - 이벤트 기반, 무상태

동기 호출 (Synchronous) - 강결합, 직접 호출
  ↓
이벤트 기반 아키텍처 (EDA) - 느슨한 결합, 비동기
  ↓
CQRS (Command Query Responsibility Segregation)
  - 읽기/쓰기 모델 분리
  ↓
이벤트 소싱 (Event Sourcing)
  - 상태 변화를 이벤트로 저장
  - CQRS와 결합 시 강력

MSA 통신
  ↓
Service Mesh (2016~)
  ├─ Istio - Envoy 사이드카, 트래픽 관리
  ├─ Linkerd - 경량, Rust 기반
  └─ Consul Connect - 서비스 디스커버리 통합

RPC (Remote Procedure Call) - 동기, 강결합
  ↓
MQ (Message Queue) - RabbitMQ, ActiveMQ, 비동기 전달
  ↓
Kafka (2011) - 이벤트 스트리밍, 분산 로그, 높은 처리량
  ↓
Pulsar (2016) - 멀티테넌시, Geo-Replication, 저장/서빙 분리

로컬 캐시 (In-Process) - HashMap, EhCache
  ↓
Memcached (2003) - 분산 메모리 캐시, 단순 Key-Value
  ↓
Redis (2009) - 다양한 자료구조, 퍼시스턴스, Pub/Sub
  ↓
분산 캐시 (Redis Cluster) - 샤딩, 고가용성, Sentinel

RPC (1970s~) - 원격 프로시저 호출
  ↓
SOAP/XML (1998) - 표준화, WSDL, 무거움
  ↓
REST/JSON (2000) - 리소스 중심, HTTP 메서드, 경량
  ↓
GraphQL (2015, Facebook) - 클라이언트 주도 쿼리, 오버/언더페칭 해결
  ↓
gRPC/Protobuf (2016, Google) - 바이너리, HTTP/2, 스트리밍, MSA 내부 통신

기계어 (Machine Code) - 0과 1, 하드웨어 직접 제어
  ↓
어셈블리 (Assembly) - 니모닉 코드, 1:1 기계어 매핑
  ↓
절차적 (Procedural) - C, Pascal, 순차 실행, 함수
  ↓
객체지향 (Object-Oriented) - C++, Java, 캡슐화/상속/다형성
  ↓
함수형 (Functional) - Haskell, Scala, 불변성, 순수 함수
  ↓
리액티브 (Reactive) - RxJava, Reactor, 비동기 스트림

스크립트 언어:
  Perl (1987) → Python (1991) → Ruby (1995) → Node.js (2009)

시스템 프로그래밍:
  C (1972) → C++ (1983) → Rust (2010) → Zig (2016)

HTML/CSS (1990s) - 정적 마크업
  ↓
jQuery (2006) - DOM 조작 단순화
  ↓
Angular (2010) - 양방향 바인딩, SPA
  ↓
React/Vue (2013/2014) - 컴포넌트, Virtual DOM
  ↓
Next.js/Nuxt (2016~) - SSR/SSG, 풀스택 프레임워크

AOT (Ahead-Of-Time) - C/C++, 네이티브 바이너리, 빠른 실행
  ↓
JIT (Just-In-Time) - Java/C#, 런타임 최적화
  ↓
바이트코드 (Bytecode) - JVM/CLR, 플랫폼 독립
  ↓
WebAssembly (2017) - 브라우저 네이티브 성능, 다중 언어 지원

정적 HTML (1990s) - 서버에서 완성된 HTML 전송
  ↓
CGI (Common Gateway Interface) - Perl/C, 동적 페이지 생성
  ↓
서버사이드 (Server-Side) - JSP/PHP/ASP, 템플릿 엔진
  ↓
AJAX/jQuery (2005~) - 비동기 부분 갱신, XHR
  ↓
SPA (Single Page Application) - Angular/React/Vue, 클라이언트 렌더링
  ↓
SSR/ISR (Next.js, 2016~) - 서버 렌더링 + 정적 생성 + 증분 재생성

LAMP (Linux + Apache + MySQL + PHP) - 전통 웹 스택
  ↓
MEAN/MERN (MongoDB + Express + Angular/React + Node.js)
  ↓
JAMstack (JavaScript + APIs + Markup) - 정적 생성, CDN
  ↓
Edge Computing (2020s~) - 엣지에서 SSR, Vercel/Cloudflare Workers

FTP (수동 업로드) - 파일 직접 전송
  ↓
CI/CD (2010s~) - 자동 빌드/배포, Jenkins/GitHub Actions
  ↓
GitOps (2017~) - Git 중심, ArgoCD/Flux, 선언적 배포
  ↓
Platform Engineering (2022~) - IDP, 셀프서비스 플랫폼

국제 표준:
  DES (56bit, 1977) - 최초 표준, 현재 취약
    ↓
  3DES (112bit, 1998) - DES 3회 적용, 과도기
    ↓
  AES (128/192/256bit, 2001) - 현재 표준, Rijndael 알고리즘

한국 표준:
  SEED (128bit, 1999) - 국내 금융권 표준
    ↓
  ARIA (128/192/256bit, 2004) - 경량, 정부/공공기관
    ↓
  LEA (128/192/256bit, 2013) - 경량 암호, IoT/모바일 최적화

RSA (1977) - 소인수분해, 2048/4096bit
  ↓
ECC/ECDSA (1985) - 타원곡선, 짧은 키, 모바일 최적화
  ↓
Ed25519 - EdDSA 기반, 빠른 서명/검증
  ↓
양자내성 암호 (Post-Quantum Cryptography)
  - CRYSTALS-Kyber (ML-KEM, FIPS 203) - 키 교환
  - CRYSTALS-Dilithium (ML-DSA, FIPS 204) - 전자서명
  - 2022 NIST 1차 선정, 2024 FIPS 표준 확정

MD5 (128bit) - 충돌 발견, 사용 금지
  ↓
SHA-1 (160bit) - 충돌 공격 성공(2017), 폐기
  ↓
SHA-2 (256/384/512bit) - 현재 표준, SHA-256 널리 사용
  ↓
SHA-3 (Keccak, 2015) - 스펀지 구조, SHA-2 대안

SSL 2.0 (1995) - 최초 상용, 심각한 취약점
  ↓
SSL 3.0 (1996) - 개선, POODLE 취약점
  ↓
TLS 1.0 (1999) - SSL 3.0 후속, BEAST 취약점
  ↓
TLS 1.2 (2008) - 현재 주력, AEAD 암호화
  ↓
TLS 1.3 (2018) - 1-RTT 핸드셰이크, 0-RTT, 취약 암호 제거

퍼셉트론 (1957) - 단층, 선형 분류
  ↓
MLP (Multi-Layer Perceptron) - 다층, 비선형
  ↓
CNN: LeNet (1998) → AlexNet (2012) → VGG (2014) → ResNet (2015)
  ↓
EfficientNet (2019) - 복합 스케일링
  ↓
ViT (Vision Transformer, 2020) - 패치 기반, Attention

RNN (1986) - 순환 구조, 기울기 소실
  ↓
LSTM/GRU (1997/2014) - 장기 의존성, 게이트 메커니즘
  ↓
Seq2Seq + Attention (2014) - 인코더-디코더, 기계번역
  ↓
Transformer (2017) - Self-Attention, 병렬 처리
  ↓
BERT (2018) - 양방향, 사전학습+미세조정
  ↓
GPT-3 (2020) - 175B 파라미터, Few-shot
  ↓
ChatGPT (2022) - GPT-3.5 + RLHF, 대화형 AI
  ↓
GPT-4 (2023) - 멀티모달, MoE 추정
  ↓
멀티모달 LLM (2024~) - 텍스트+이미지+음성+영상 통합

GAN (Generative Adversarial Network, 2014)
  ↓
StyleGAN (2018) - 스타일 기반 생성, 고해상도 얼굴
  ↓
Diffusion Model (2020) - 노이즈 제거 기반, 안정적 학습
  ↓
DALL-E / Stable Diffusion (2022) - Text-to-Image
  ↓
Sora (2024) - Text-to-Video, 물리 시뮬레이션

Q-Learning (1989) - 테이블 기반, 이산 행동
  ↓
DQN (2013, DeepMind) - 딥러닝 + Q-Learning, Atari
  ↓
A3C (2016) - 비동기, Actor-Critic
  ↓
PPO (2017) - 안정적 학습, 범용
  ↓
RLHF (2022) - 인간 피드백 강화학습, ChatGPT 핵심
  ↓
DPO (Direct Preference Optimization) - 보상 모델 없이 직접 최적화

규칙 기반 (Rule-based) - if-then, 전문가 시스템
  ↓
단일 LLM Agent - 프롬프트 기반, 도구 사용
  ↓
ReAct (2022) - Reasoning + Acting, 추론-행동 루프
  ↓
멀티에이전트 (2024~) - 역할 분담, 협업, AutoGen/CrewAI
  ↓
Agentic AI (2024~) - 자율 계획/실행, 복잡한 워크플로우

Pruning (가지치기) - 불필요한 가중치 제거
  ↓
Quantization (INT8) - 부동소수점 → 정수, 추론 가속
  ↓
Knowledge Distillation - 큰 모델 → 작은 모델 지식 전달
  ↓
LoRA/QLoRA (2023) - 저랭크 적응, 효율적 미세조정
  ↓
On-Device AI (2024~) - 엣지/모바일 디바이스 직접 추론

수동 배포 - FTP, SSH, 콘솔
  ↓
스크립트 자동화 - Shell, Makefile
  ↓
CI/CD (Jenkins, 2011~) - 자동 빌드/테스트/배포
  ↓
GitOps (ArgoCD/Flux, 2017~) - Git 중심, 선언적, 자동 동기화

쉘 스크립트 - 절차적, 멱등성 없음
  ↓
Ansible (2012) - YAML, 에이전트리스, SSH
  ↓
Terraform (2014) - HCL, 멀티클라우드, State 관리
  ↓
Pulumi (2018) - 일반 프로그래밍 언어 (Python/TypeScript)
  ↓
Crossplane (2018~) - K8s CRD 기반, 인프라를 K8s 리소스로 관리

Nagios (1999) - 전통 모니터링, 플러그인 기반
  ↓
Zabbix (2001) - 에이전트 기반, 임계값 알림
  ↓
Prometheus + Grafana (2012~) - Pull 기반, PromQL, 시계열 메트릭
  ↓
OpenTelemetry (2019~) - 통합 Observability, 벤더 중립 표준

syslog (1980s) - 전통 시스템 로그
  ↓
ELK Stack (Elasticsearch + Logstash + Kibana, 2010~) - 중앙 집계, 검색
  ↓
Loki (2018, Grafana) - 경량, 로그 라벨 인덱싱, K8s 네이티브
  ↓
통합 Observability 플랫폼 - Metrics + Logs + Traces 통합 분석