LAYER 11 - PLATFORM PRODUCT & RELIABILITY ENGINEERING

Tài nguyên: Google SRE Book & SRE Workbook, Seeking SRE, FinOps Foundation framework & Cloud FinOps (Storment & Fuller), Chaos Engineering (Rosenthal & Jones), Principles of Chaos, docs Chaos Mesh/Litmus/Velero, AWS/Azure DR whitepapers.

KHỐI A - Platform as Product (Ngày 1-30) → P1

Ngày 1: Khởi động Layer 11

• Mục tiêu: Ghép product + reliability mindset.

• Lý thuyết: platform vừa là sản phẩm vừa phải tin cậy.

• Thực hành: Repo platform-reliability/; khung roadmap + reliability.

Ngày 2: Reliability + product mindset

• Mục tiêu: Coi độ tin cậy là tính năng.

• Lý thuyết: reliability as a feature, internal customer.

• Thực hành: Liệt kê kỳ vọng tin cậy của internal customer.

Ngày 3: API lifecycle

• Mục tiêu: Vòng đời API nền tảng.

• Lý thuyết: design → release → deprecate → sunset.

• Thực hành: Vẽ lifecycle cho một platform API.

Ngày 4: API versioning

• Mục tiêu: Tiến hoá không phá vỡ.

• Lý thuyết: semver, backward compatibility, contract (nối Layer 4 CRD).

• Thực hành: Chính sách versioning cho API.

Ngày 5: Breaking vs non-breaking

• Mục tiêu: Biết đâu là phá vỡ.

• Lý thuyết: additive vs breaking change, compatibility rules.

• Thực hành: Phân loại một tập thay đổi.

Ngày 6: Deprecation policy

• Mục tiêu: Ngưng dịch vụ có trách nhiệm.

• Lý thuyết: deprecation window, migration path, communication.

• Thực hành: Viết deprecation policy.

Ngày 7: API contract & stability

• Mục tiêu: Cam kết ổn định.

• Lý thuyết: stability guarantees, support tiers.

• Thực hành: Định nghĩa stability tiers (alpha/beta/stable).

Ngày 8: Adoption strategy

• Mục tiêu: Được dùng (nối Layer 6).

• Lý thuyết: voluntary adoption, migration incentive.

• Thực hành: Kế hoạch adoption cho một capability.

Ngày 9: Internal marketing

• Mục tiêu: Lan toả nội bộ.

• Lý thuyết: evangelism, changelog, champion (nối Leadership).

• Thực hành: Bản tin/changelog mẫu.

Ngày 10: Reliability roadmap

• Mục tiêu: Định hướng tin cậy.

• Lý thuyết: roadmap gắn với reliability goals.

• Thực hành: Draft reliability roadmap.

Ngày 11: Stakeholder management

• Mục tiêu: Căn chỉnh nhiều bên.

• Lý thuyết: product/security/finance/leadership (nối Leadership).

• Thực hành: Bản đồ stakeholder cho reliability.

Ngày 12: Prioritizing reliability

• Mục tiêu: Làm đúng việc.

• Lý thuyết: impact/risk, cost of downtime.

• Thực hành: Xếp hạng reliability backlog.

Ngày 13: Reliability tiers

• Mục tiêu: Không phải mọi thứ cần 99.99%.

• Lý thuyết: service tiers, reliability theo tầm quan trọng.

• Thực hành: Phân tier service.

Ngày 14: Features vs reliability

• Mục tiêu: Cân bằng.

• Lý thuyết: velocity vs stability, error budget làm trọng tài (preview).

• Thực hành: Khung quyết định.

Ngày 15: Reliability as product feature

• Mục tiêu: Bán được độ tin cậy.

• Lý thuyết: reliability là giá trị, không phải chi phí thuần.

• Thực hành: Value prop reliability.

Ngày 16: Internal customer feedback

• Mục tiêu: Lắng nghe.

• Lý thuyết: feedback loop, NPS nội bộ (nối Layer 6).

• Thực hành: Kênh feedback.

Ngày 17: SLA & support tiers

• Mục tiêu: Cam kết dịch vụ.

• Lý thuyết: internal SLA, support model, on-call tie-in.

• Thực hành: Định nghĩa support tiers.

Ngày 18: OKRs for platform

• Mục tiêu: Mục tiêu đo được.

• Lý thuyết: reliability OKR, gắn error budget.

• Thực hành: Draft OKR quý.

Ngày 19: Measuring platform value

• Mục tiêu: Chứng minh giá trị (nối Layer 6).

• Lý thuyết: DORA + reliability + adoption metrics.

• Thực hành: Bộ metric giá trị.

Ngày 20: Build vs buy

• Mục tiêu: Chọn công cụ reliability.

• Lý thuyết: OSS vs SaaS cho SLO/chaos/DR.

• Thực hành: Quyết định build/buy.

Ngày 21: Reliability culture

• Mục tiêu: Văn hoá sở hữu.

• Lý thuyết: you-build-you-run, ownership.

• Thực hành: Nguyên tắc văn hoá reliability.

Ngày 22: Cost of downtime

• Mục tiêu: Đóng khung kinh doanh.

• Lý thuyết: revenue/trust impact, tính cost downtime.

• Thực hành: Ước tính cost downtime một service.

Ngày 23: Risk management

• Mục tiêu: Quản lý rủi ro.

• Lý thuyết: risk register, error budget như risk tool (preview).

• Thực hành: Risk register cho platform.

Ngày 24: Reliability vs velocity

• Mục tiêu: Trung tâm của SRE.

• Lý thuyết: error budget hoà giải mâu thuẫn dev vs ops.

• Thực hành: Khung cân bằng.

Ngày 25: P1 - cấu trúc roadmap

• Mục tiêu: Đóng khung P1.

• Lý thuyết: roadmap + API lifecycle + adoption + tiers.

• Thực hách: platform-roadmap-design.md.

Ngày 26: P1 - API lifecycle & versioning

• Mục tiêu: Chính sách API.

• Lý thuyết: versioning + deprecation policy.

• Thực hành: Viết policy hoàn chỉnh.

Ngày 27: P1 - adoption + reliability tiers

• Mục tiêu: Adoption có kế hoạch.

• Lý thuyết: tiers + adoption strategy.

• Thực hành: Kế hoạch adoption + tier map.

Ngày 28: P1 - stakeholder alignment

• Mục tiêu: Đồng thuận.

• Lý thuyết: trình bày roadmap thuyết phục (nối Leadership).

• Thực hành: Slide/RFC roadmap.

Ngày 29: P1 - finalize roadmap

• Mục tiêu: Hoàn thiện.

• Lý thuyết: roadmap + metrics + OKR.

• Thực hành: Roadmap doc hoàn chỉnh.

Ngày 30: CỘT MỐC 30

• Mục tiêu: Chốt platform-as-product; release P1.

• Lý thuyết: Ôn A; kiểm kê: roadmap + API lifecycle + adoption + tiers.

• Thực hành: P1 done; đề thi #1 (platform product/API lifecycle) + tự chấm; blog #107 ("Vận hành nền tảng như một sản phẩm: roadmap, API lifecycle, adoption"); tag layer11-day030; nghỉ nửa ngày. Đã đi 30/180 (17%).

KHỐI B - SRE & SLI/SLO/Error Budget (Ngày 31-66) → P2

Ngày 31: SRE - tổng quan

• Mục tiêu: SRE là gì.

• Lý thuyết: SRE = ops bằng tư duy software, nguyên tắc Google SRE.

• Thực hành: So SRE vs DevOps vs traditional ops.

Ngày 32: Availability math

• Mục tiêu: Nói bằng số.

• Lý thuyết: nines, downtime allowance, availability = uptime/total.

• Thực hách: Tính downtime cho 99.9% vs 99.99%.

Ngày 33: SLI

• Mục tiêu: Chọn chỉ số đúng.

• Lý thuyết: SLI = tỷ lệ good/valid events, chọn SLI phản ánh user.

• Thực hành: Định nghĩa SLI cho một service.

Ngày 34: SLI measurement

• Mục tiêu: Đo đúng cách.

• Lý thuyết: request-based vs window-based, đo ở đâu (nối Layer 7).

• Thực hành: Đo một SLI từ metrics thật.

Ngày 35: Loại SLI

• Mục tiêu: Nhiều khía cạnh.

• Lý thuyết: availability/latency/quality/freshness/correctness.

• Thực hành: Chọn bộ SLI cho một service.

Ngày 36: SLO

• Mục tiêu: Đặt mục tiêu.

• Lý thuyết: SLO target, dựa trên user expectation + data.

• Thực hành: Đặt SLO cho SLI đã chọn.

Ngày 37: SLO windows

• Mục tiêu: Cửa sổ đánh giá.

• Lý thuyết: rolling vs calendar window.

• Thực hành: Chọn window; đo tuân thủ.

Ngày 38: SLO latency

• Mục tiêu: Latency SLO đúng.

• Lý thuyết: percentile (p95/p99), threshold (nối Layer 7).

• Thực hành: SLO latency có threshold + percentile.

Ngày 39: Multi-SLO

• Mục tiêu: Nhiều mục tiêu.

• Lý thuyết: multi-tier SLO, per-journey.

• Thực hành: Bộ SLO nhiều tầng.

Ngày 40: Error budget - toán

• Mục tiêu: Nền của SRE.

• Lý thuyết: error budget = 1 − SLO, ý nghĩa.

• Thực hành: Tính error budget cho các SLO.

Ngày 41: Burn rate

• Mục tiêu: Tốc độ tiêu budget.

• Lý thuyết: burn rate, thời gian cạn budget.

• Thực hành: Tính burn rate từ error rate.

Ngày 42: Error budget policy

• Mục tiêu: Budget dẫn quyết định.

• Lý thuyết: policy khi budget cạn (freeze/ưu tiên reliability).

• Thực hành: Viết error budget policy.

Ngày 43: Budget-driven decisions

• Mục tiêu: Trọng tài dev vs ops.

• Lý thuyết: release freeze, ưu tiên reliability khi cạn budget.

• Thực hành: Kịch bản ra quyết định theo budget.

Ngày 44: SLA vs SLO vs SLI

• Mục tiêu: Phân biệt rõ.

• Lý thuyết: SLA (hợp đồng, phạt) vs SLO (nội bộ) vs SLI (đo).

• Thực hành: Map ba khái niệm cho một dịch vụ.

Ngày 45: SLO thực tế

• Mục tiêu: SLO khả thi.

• Lý thuyết: data-driven, không quá cao/thấp.

• Thực hành: Đặt SLO từ dữ liệu lịch sử.

Ngày 46: SLO từ user journey

• Mục tiêu: Đo cái user quan tâm.

• Lý thuyết: critical user journey, SLO theo journey.

• Thực hành: SLO cho một journey quan trọng.

Ngày 47: Composite/dependency SLO

• Mục tiêu: SLO khi phụ thuộc.

• Lý thuyết: SLO của service phụ thuộc nhiều service.

• Thực hành: Tính SLO tổng từ dependency.

Ngày 48: Đo SLI thực chiến

• Mục tiêu: Từ metrics ra SLI (nối Layer 7).

• Lý thuyết: PromQL cho SLI, good/total.

• Thực hành: SLI query trên Prometheus.

Ngày 49: SLO dashboard

• Mục tiêu: Nhìn thấy SLO (nối Layer 7).

• Lý thuyết: dashboard SLO + budget còn lại.

• Thực hành: Dashboard SLO cho một service.

Ngày 50: Burn-rate alerting (sâu)

• Mục tiêu: Cảnh báo đúng.

• Lý thuyết: alert theo burn rate (nối Layer 7).

• Thực hành: Alert burn-rate.

Ngày 51: Multi-window multi-burn-rate

• Mục tiêu: Cảnh báo tinh (SRE workbook).

• Lý thuyết: kết hợp fast/slow burn, nhiều window.

• Thực hành: Bộ alert MWMBR hoàn chỉnh.

Ngày 52: Error budget reporting

• Mục tiêu: Báo cáo budget.

• Lý thuyết: budget burndown, trend.

• Thực hành: Report budget định kỳ.

Ngày 53: SLO review cadence

• Mục tiêu: SLO sống.

• Lý thuyết: review, điều chỉnh SLO theo thời gian.

• Thực hành: Quy trình review SLO.

Ngày 54: Negotiating targets

• Mục tiêu: Đồng thuận mục tiêu.

• Lý thuyết: thương lượng SLO với stakeholder.

• Thực hành: Kịch bản negotiate SLO.

Ngày 55: SLO anti-patterns

• Mục tiêu: Tránh sai.

• Lý thuyết: SLO 100%, SLO không đo user, gaming.

• Thực hành: Rà + sửa SLO xấu.

Ngày 56: Kinh tế của nines

• Mục tiêu: Chi phí độ tin cậy.

• Lý thuyết: mỗi nine thêm chi phí bao nhiêu (nối Khối D).

• Thực hành: Cost vs reliability curve.

Ngày 57: SLO cho platform service

• Mục tiêu: Đo chính platform.

• Lý thuyết: SLO cho API/IDP/CI (nối Layer 6).

• Thực hành: SLO cho một platform capability.

Ngày 58: SLO cho data/ML

• Mục tiêu: Reliability data/AI (nối Layer 9/10).

• Lý thuyết: freshness/quality SLO cho pipeline.

• Thực hành: SLO cho một data pipeline.

Ngày 59: Reliability testing

• Mục tiêu: Kiểm chứng trước prod (nối Layer 6).

• Lý thuyết: progressive delivery gate theo SLO.

• Thực hành: SLO-based promotion (nối Layer 6).

Ngày 60: CỘT MỐC 60

• Mục tiêu: Chốt SLI/SLO/error budget.

• Lý thuyết: Ôn B tới giờ; kiểm kê: SLI/SLO + error budget + burn-rate + dashboard.

• Thực hành: Đề thi #2 (SLI/SLO/error budget/burn-rate) + tự chấm; blog #108 ("SLO và error budget: toán học của độ tin cậy"); tag layer11-day060; nghỉ nửa ngày. Đã đi 60/180 (33%).

Ngày 61: P2 - thiết kế SLO framework

• Mục tiêu: Đóng khung P2.

• Lý thuyết: SLI → SLO → budget → dashboard → alert → policy.

• Thực hách: slo-framework-design.md.

Ngày 62: P2 - define SLIs

• Mục tiêu: Chọn chỉ số.

• Lý thuyết: SLI cho các service.

• Thực hành: Bộ SLI đo được.

Ngày 63: P2 - set SLOs + budget

• Mục tiêu: Mục tiêu + ngân sách.

• Lý thuyết: SLO + error budget.

• Thực hành: SLO + budget cho services.

Ngày 64: P2 - SLO dashboard

• Mục tiêu: Nhìn thấy (nối Layer 7).

• Lý thuyết: dashboard SLO + budget burndown.

• Thực hành: Dashboard hoàn chỉnh.

Ngày 65: P2 - alerts + policy

• Mục tiêu: Cảnh báo + chính sách.

• Lý thuyết: burn-rate alert + error budget policy.

• Thực hành: Alert + policy áp dụng.

Ngày 66: P2 - SLO dashboard + error budget policy

• Mục tiêu: Release P2.

• Lý thuyết: rà "done": SLI/SLO + dashboard + alert + policy.

• Thực hành: Đóng gói + blog #109 ("Một SLO dashboard và error budget policy vận hành được"). P2 done.

KHỐI C - Toil, On-call, Incident Management (Ngày 67-96) → P3

Ngày 67: Toil

• Mục tiêu: Nhận diện việc lặp vô giá trị.

• Lý thuyết: toil = manual/repetitive/automatable/no enduring value.

• Thực hành: Kiểm kê toil của một team.

Ngày 68: Toil budget

• Mục tiêu: Giới hạn toil.

• Lý thuyết: đo % thời gian toil, ngưỡng (< 50%).

• Thực hành: Đo toil hiện tại.

Ngày 69: Eliminating toil

• Mục tiêu: Tự động hoá.

• Lý thuyết: ưu tiên automation theo tần suất × chi phí.

• Thực hành: Chọn + tự động hoá một toil lớn.

Ngày 70: Automation tradeoff

• Mục tiêu: Không automate mù.

• Lý thuyết: cost automation vs saving, khi nào không nên.

• Thực hành: Quyết định automate hay không.

Ngày 71: On-call - triết lý

• Mục tiêu: On-call bền vững.

• Lý thuyết: sustainable on-call, không kiệt sức.

• Thực hành: Nguyên tắc on-call.

Ngày 72: On-call rotation

• Mục tiêu: Lịch trực hợp lý.

• Lý thuyết: rotation, follow-the-sun, primary/secondary.

• Thực hành: Thiết kế rotation.

Ngày 73: On-call load & burnout

• Mục tiêu: Bảo vệ con người.

• Lý thuyết: page load limit, comp time, burnout signals.

• Thực hành: Đo + giảm on-call load.

Ngày 74: Escalation

• Mục tiêu: Leo thang đúng.

• Lý thuyết: escalation policy, ai khi nào.

• Thực hành: Escalation policy (nối Layer 7 routing).

Ngày 75: Alerting for on-call

• Mục tiêu: Chỉ page cái đáng (nối Layer 7).

• Lý thuyết: actionable, symptom-based, giảm noise.

• Thực hành: Audit + cắt alert page nhiễu.

Ngày 76: Paging philosophy

• Mục tiêu: Trân trọng giấc ngủ.

• Lý thuyết: page = cần người ngay, còn lại → ticket.

• Thực hành: Phân loại alert page vs ticket.

Ngày 77: Incident management - tổng quan

• Mục tiêu: Xử lý sự cố có hệ thống.

• Lý thuyết: lifecycle: detect → respond → mitigate → resolve → learn.

• Thực hành: Vẽ incident lifecycle.

Ngày 78: Severity levels

• Mục tiêu: Phân loại sự cố.

• Lý thuyết: SEV1-4, tiêu chí, tác động.

• Thực hành: Định nghĩa severity matrix.

Ngày 79: Incident Command System

• Mục tiêu: Vai trò rõ khi khủng hoảng.

• Lý thuyết: IC, ops lead, comms lead, scribe.

• Thực hành: Gán vai trò cho một kịch bản.

Ngày 80: Incident response process

• Mục tiêu: Quy trình phản ứng.

• Lý thuyết: declare → coordinate → mitigate → resolve.

• Thực hành: Runbook incident response.

Ngày 81: Incident communication

• Mục tiêu: Giao tiếp khi sự cố.

• Lý thuyết: status page, stakeholder update, cadence.

• Thực hành: Template communication.

Ngày 82: MTTD/MTTR

• Mục tiêu: Đo incident (nối Layer 6 DORA).

• Lý thuyết: MTTD, MTTR, time-to-mitigate.

• Thực hành: Đo + phân tích MTTR.

Ngày 83: Blameless postmortem

• Mục tiêu: Học, không đổ lỗi.

• Lý thuyết: blameless culture, system-focused.

• Thực hành: Nguyên tắc blameless.

Ngày 84: Postmortem structure

• Mục tiêu: Postmortem chất lượng.

• Lý thuyết: timeline, impact, root cause, action items.

• Thực hành: Viết một postmortem theo template.

Ngày 85: Root cause analysis

• Mục tiêu: Tìm nguyên nhân thật.

• Lý thuyết: 5 whys, causal chain, không dừng ở "human error".

• Thực hành: RCA cho một sự cố mô phỏng.

Ngày 86: Contributing factors

• Mục tiêu: Nhìn hệ thống.

• Lý thuyết: contributing factors vs single root cause.

• Thực hành: Phân tích multi-factor.

Ngày 87: Action items

• Mục tiêu: Ngăn tái diễn.

• Lý thuyết: actionable, có owner, có deadline, follow-through.

• Thực hành: Action items + tracking.

Ngày 88: Learning from incidents

• Mục tiêu: Biến sự cố thành cải thiện.

• Lý thuyết: incident retrospective, pattern across incidents.

• Thực hành: Tổng hợp bài học nhiều incident.

Ngày 89: Incident review & sharing

• Mục tiêu: Lan toả bài học.

• Lý thuyết: review meeting, chia sẻ rộng.

• Thực hành: Format incident review.

Ngày 90: CỘT MỐC 90

• Mục tiêu: Chốt toil/on-call/incident.

• Lý thuyết: Ôn C tới giờ; kiểm kê: toil reduction + on-call + incident + postmortem.

• Thực hành: Đề thi #3 (on-call/incident/postmortem) + tự chấm; blog #110 ("Incident management không đổ lỗi: từ page tới postmortem"); tag layer11-day090; nghỉ nửa ngày. Đã đi 90/180 (50%).

Ngày 91: Error budget từ incident

• Mục tiêu: Nối incident vào SLO (nối Khối B).

• Lý thuyết: incident tiêu error budget, budget-driven priority.

• Thực hành: Tính budget bị incident tiêu.

Ngày 92: Runbook

• Mục tiêu: Vận hành khi sự cố (nối Layer 6).

• Lý thuyết: runbook actionable, cập nhật.

• Thực hành: Viết runbook cho một failure mode.

Ngày 93: Runbook automation

• Mục tiêu: Từ runbook tới auto.

• Lý thuyết: automated remediation, self-healing.

• Thực hành: Auto-remediate một sự cố thường gặp.

Ngày 94: P3 - thiết kế

• Mục tiêu: Đóng khung P3.

• Lý thuyết: on-call + escalation + incident process + runbook + postmortem.

• Thực hách: incident-mgmt-design.md.

Ngày 95: P3 - on-call + escalation + runbook

• Mục tiêu: Vận hành được.

• Lý thuyết: rotation + escalation + runbook library.

• Thực hành: Setup on-call + runbook.

Ngày 96: P3 - Incident management

• Mục tiêu: Release P3.

• Lý thuyết: rà "done": on-call + incident process + postmortem + runbook.

• Thực hành: Đóng gói + blog #111 ("Xây một hệ thống incident management: on-call, escalation, postmortem"). P3 done.

KHỐI D - Cost & CapacityFinOps (Ngày 97-126) → P4

Ngày 97: FinOps framework

• Mục tiêu: Quản trị chi phí cloud.

• Lý thuyết: inform → optimize → operate, ownership.

• Thực hành: Đánh giá maturity FinOps.

Ngày 98: Cost visibility

• Mục tiêu: Thấy tiền đi đâu.

• Lý thuyết: cost breakdown, granularity.

• Thực hành: Phân tích cost một tài khoản.

Ngày 99: Cost allocation

• Mục tiêu: Gán chi phí đúng chủ.

• Lý thuyết: tagging (nối Layer 5), allocation, shared cost.

• Thực hành: Allocate cost theo team.

Ngày 100:🏁 NGHI THỨC 100 NGÀY

• Mục tiêu: Kiểm kê lớn giữa Layer 11.

• Lý thuyết: Ôn A→C + đầu D; kiểm kê lớn: roadmap (P1) + SLO (P2) + incident (P3) + FinOps khởi đầu; đối chiếu "Sâu".

• Thực hành: Đề thi #4 tích lũy (product+SLO+incident+cost) + tự chấm theo rubric; blog #112 ("100 ngày reliability: SLO, incident, và bước vào FinOps"); tag layer11-day100; nghỉ nửa ngày. Đã đi 100/180 (56%).

Ngày 101: Showback vs chargeback

• Mục tiêu: Trách nhiệm chi phí.

• Lý thuyết: showback (hiển thị) vs chargeback (tính phí).

• Thực hành: Chọn mô hình cho tổ chức.

Ngày 102: Rightsizing

• Mục tiêu: Không thừa tài nguyên.

• Lý thuyết: rightsize compute/memory theo thực tế.

• Thực hành: Rightsize một workload.

Ngày 103: Spot/reserved/savings

• Mục tiêu: Mua đúng cách (nối Layer 5).

• Lý thuyết: spot, reserved, savings plan, commitment.

• Thực hành: Tối ưu mix mua.

Ngày 104: Autoscaling cho cost

• Mục tiêu: Trả theo dùng (nối Layer 4).

• Lý thuyết: scale-to-zero, HPA/Karpenter tiết kiệm.

• Thực hành: Cost giảm nhờ autoscaling.

Ngày 105: Storage/egress cost

• Mục tiêu: Chi phí ẩn (nối Layer 3/5).

• Lý thuyết: storage tiering, egress, cross-AZ.

• Thực hành: Giảm egress/storage cost.

Ngày 106: Unit economics

• Mục tiêu: Cost per đơn vị.

• Lý thuyết: cost per request/user/tenant.

• Thực hành: Tính unit cost một service.

Ngày 107: GPU/compute economics

• Mục tiêu: GPU rất đắt (nối Layer 10).

• Lý thuyết: cost per training/token, GPU utilization.

• Thực hành: Tối ưu cost GPU workload.

Ngày 108: Cost anomaly detection

• Mục tiêu: Bắt tăng vọt.

• Lý thuyết: anomaly detection, budget alert.

• Thực hành: Alert khi cost bất thường.

Ngày 109: Cost dashboards

• Mục tiêu: Nhìn chi phí (nối Layer 7).

• Lý thuyết: dashboard cost theo team/service.

• Thực hành: Dashboard FinOps.

Ngày 110: FinOps culture

• Mục tiêu: Ai cũng quan tâm cost.

• Lý thuyết: accountability, cost trong định nghĩa done (nối Layer 6).

• Thực hành: Đưa cost vào review.

Ngày 111: Capacity planning - nền

• Mục tiêu: Đủ tài nguyên, không thừa.

• Lý thuyết: demand vs supply, lead time.

• Thực hành: Khung capacity planning.

Ngày 112: Demand forecasting

• Mục tiêu: Dự báo nhu cầu.

• Lý thuyết: trend, seasonality, growth.

• Thực hành: Forecast tài nguyên một service.

Ngày 113: Headroom & buffer

• Mục tiêu: Dự phòng đủ.

• Lý thuyết: headroom, N+1/N+2, buffer cho spike.

• Thực hành: Đặt headroom hợp lý.

Ngày 114: Load testing cho capacity

• Mục tiêu: Biết giới hạn (nối Layer 6).

• Lý thuyết: load test, tìm breaking point.

• Thực hành: Load test một service; đo max.

Ngày 115: Capacity models

• Mục tiêu: Mô hình hoá.

• Lý thuyết: resource per unit load, scaling model.

• Thực hành: Model capacity cho một service.

Ngày 116: Scaling limits

• Mục tiêu: Biết trần.

• Lý thuyết: bottleneck, hard limits, quota (nối Layer 5).

• Thực hành: Tìm scaling bottleneck.

Ngày 117: Efficiency vs reliability

• Mục tiêu: Cân bằng.

• Lý thuyết: utilization cao vs headroom, tradeoff.

• Thực hành: Chọn điểm cân bằng.

Ngày 118: Reserved capacity

• Mục tiêu: Cam kết dài hạn.

• Lý thuyết: reserved capacity, commitment discount.

• Thực hành: Kế hoạch commitment.

Ngày 119: Multi-cloud/region cost

• Mục tiêu: Cost xuyên vùng (nối Layer 5).

• Lý thuyết: region cost khác nhau, DR cost.

• Thực hành: So cost multi-region.

Ngày 120: CỘT MỐC 120

• Mục tiêu: Chốt FinOps + capacity.

• Lý thuyết: Ôn D tới giờ; kiểm kê: cost visibility/optimize + capacity planning.

• Thực hành: Đề thi #5 (FinOps/capacity) + tự chấm; blog #113 ("FinOps và capacity planning: hiệu quả mà vẫn tin cậy"); tag layer11-day120; nghỉ nửa ngày. Đã đi 120/180 (67%).

Ngày 121: Sustainability

• Mục tiêu: Xanh hơn.

• Lý thuyết: carbon-aware, efficiency = sustainability.

• Thực hành: Ước lượng carbon một workload.

Ngày 122: Cost of reliability

• Mục tiêu: Redundancy tốn tiền.

• Lý thuyết: cost của HA/DR/multi-region (nối Khối F).

• Thực hành: Cost vs reliability cho một tier.

Ngày 123: FinOps cho data/AI

• Mục tiêu: Cost data/AI (nối Layer 9/10).

• Lý thuyết: cost query/training/serving.

• Thực hành: Tối ưu cost một data/AI workload.

Ngày 124: P4 - thiết kế

• Mục tiêu: Đóng khung P4.

• Lý thuyết: cost dashboard + allocation + capacity model.

• Thực hách: finops-capacity-design.md.

Ngày 125: P4 - cost dashboard + allocation

• Mục tiêu: Nhìn + gán chi phí.

• Lý thuyết: dashboard + tagging + allocation.

• Thực hành: Cost dashboard theo team.

Ngày 126: P4 - FinOps + capacity plan

• Mục tiêu: Release P4.

• Lý thuyết: rà "done": cost visibility/optimize + capacity model.

• Thực hành: Đóng gói + blog #114 ("FinOps dashboard và một capacity plan có số liệu"). P4 done.

KHỐI E - Chaos Engineering (Ngày 127-150) → P5

Ngày 127: Chaos engineering - nguyên lý

• Mục tiêu: Chủ động tìm điểm yếu.

• Lý thuyết: Principles of Chaos: hypothesis, real-world events, prod.

• Thực hành: Đọc principles; ý tưởng thí nghiệm.

Ngày 128: Steady state hypothesis

• Mục tiêu: Định nghĩa "bình thường".

• Lý thuyết: steady state (metric/SLO), hypothesis.

• Thực hành: Định nghĩa steady state một service.

Ngày 129: Blast radius & safety

• Mục tiêu: Chaos an toàn.

• Lý thuyết: minimize blast radius, abort condition.

• Thực hành: Thiết kế thí nghiệm an toàn.

Ngày 130: Fault injection types

• Mục tiêu: Các loại lỗi tiêm.

• Lý thuyết: pod kill, network, resource, dependency.

• Thực hành: Liệt kê fault cho một hệ.

Ngày 131: Chaos Mesh

• Mục tiêu: Chaos k8s-native (nối Layer 4).

• Lý thuyết: Chaos Mesh CRD, experiment.

• Thực hành: Dựng Chaos Mesh; chạy pod-kill.

Ngày 132: Chaos Mesh - faults

• Mục tiêu: Nhiều loại lỗi.

• Lý thuyết: pod/network/IO/stress/time chaos.

• Thực hành: Network delay + IO fault.

Ngày 133: Litmus

• Mục tiêu: Lựa chọn khác.

• Lý thuyết: Litmus experiments, chaos hub.

• Thực hành: Chạy một Litmus experiment.

Ngày 134: Gremlin

• Mục tiêu: Chaos SaaS.

• Lý thuyết: Gremlin, managed chaos.

• Thực hành: So Gremlin với Chaos Mesh/Litmus.

Ngày 135: So sánh công cụ chaos

• Mục tiêu: Chọn công cụ.

• Lý thuyết: Chaos Mesh vs Litmus vs Gremlin.

• Thực hành: Bảng đánh đổi.

Ngày 136: Network chaos

• Mục tiêu: Mạng lỗi (nối Layer 3).

• Lý thuyết: latency, loss, partition, DNS.

• Thực hành: Partition mạng; quan sát hệ.

Ngày 137: Resource chaos

• Mục tiêu: Tài nguyên cạn.

• Lý thuyết: CPU/memory/IO stress.

• Thực hành: Stress memory; quan sát OOM (nối Layer 2).

Ngày 138: Application chaos

• Mục tiêu: Lỗi ứng dụng.

• Lý thuyết: exception injection, slow response.

• Thực hành: Tiêm lỗi app-level.

Ngày 139: Dependency failure

• Mục tiêu: Khi phụ thuộc hỏng.

• Lý thuyết: DB/cache/downstream fail, circuit breaking (nối Layer 4).

• Thực hành: Kill dependency; kiểm graceful degradation.

Ngày 140: Chaos trong CI/CD

• Mục tiêu: Chaos tự động (nối Layer 6).

• Lý thuyết: chaos trong pipeline, pre-prod.

• Thực hành: Chaos test trong pipeline.

Ngày 141: Continuous chaos

• Mục tiêu: Chaos liên tục.

• Lý thuyết: automated chaos, chaos as regression.

• Thực hành: Lịch chaos định kỳ.

Ngày 142: Game-day - lập kế hoạch

• Mục tiêu: Diễn tập có tổ chức.

• Lý thuyết: game-day plan, hypothesis, scope.

• Thực hành: Kế hoạch một game-day.

Ngày 143: Game-day - chạy

• Mục tiêu: Thực thi diễn tập.

• Lý thuyết: roles, run, observe, learnings.

• Thực hành: Chạy game-day (mô phỏng).

Ngày 144: Chaos maturity

• Mục tiêu: Đo trưởng thành.

• Lý thuyết: chaos maturity model.

• Thực hành: Tự chấm maturity.

Ngày 145: Chaos + observability

• Mục tiêu: Quan sát trong chaos (nối Layer 7).

• Lý thuyết: verify steady state qua metrics/traces.

• Thực hành: Observe hệ dưới chaos.

Ngày 146: Chaos safety & rollback

• Mục tiêu: Không gây sự cố thật.

• Lý thuyết: abort, rollback, guardrails.

• Thực hành: Auto-abort khi vượt ngưỡng.

Ngày 147: Verifying resilience

• Mục tiêu: Chứng minh chịu lỗi.

• Lý thuyết: resilience verified qua chaos + SLO.

• Thực hành: Verify một resilience claim.

Ngày 148: P5 - thiết kế thí nghiệm

• Mục tiêu: Đóng khung P5.

• Lý thuyết: hypothesis + fault + steady state + abort.

• Thực hách: chaos-experiments-design.md.

Ngày 149: P5 - run game-day

• Mục tiêu: Diễn tập thật.

• Lý thuyết: game-day + learnings + action items.

• Thực hành: Chạy game-day + ghi bài học.

Ngày 150: CỘT MỐC 150

• Mục tiêu: Chốt chaos; release P5.

• Lý thuyết: Ôn E; kiểm kê: chaos experiments + game-day + resilience verified.

• Thực hành: P5 done; đề thi #6 (chaos/game-day/resilience) + tự chấm; blog #115 ("Chaos engineering và game-day: chủ động tìm điểm gãy"); tag layer11-day150; nghỉ nửa ngày. Đã đi 150/180 (83%).

KHỐI F - Disaster Recovery (Ngày 151-174) → P6 (build)

Ngày 151: DR - nền

• Mục tiêu: Chuẩn bị cho thảm hoạ.

• Lý thuyết: DR vs HA, business continuity (BCP).

• Thực hành: Phân biệt HA vs DR cho một hệ.

Ngày 152: RTO & RPO

• Mục tiêu: Hai chỉ số DR cốt lõi.

• Lý thuyết: RTO (thời gian phục hồi), RPO (mất dữ liệu tối đa).

• Thực hành: Đặt RTO/RPO cho các tier.

Ngày 153: Backup/restore

• Mục tiêu: Chiến lược cơ bản.

• Lý thuyết: backup + restore, RTO cao, rẻ.

• Thực hành: Backup + restore một hệ.

Ngày 154: Pilot light

• Mục tiêu: Chiến lược trung gian.

• Lý thuyết: core tối thiểu chạy sẵn, scale khi cần.

• Thực hành: Thiết kế pilot light.

Ngày 155: Warm standby

• Mục tiêu: Phục hồi nhanh hơn.

• Lý thuyết: standby thu nhỏ luôn chạy.

• Thực hành: Thiết kế warm standby.

Ngày 156: Active-active

• Mục tiêu: RTO/RPO gần 0.

• Lý thuyết: multi-site active-active, phức tạp & đắt.

• Thực hành: Thiết kế active-active (nối Layer 5).

Ngày 157: Backup 3-2-1

• Mục tiêu: Backup đúng cách.

• Lý thuyết: 3 copy, 2 media, 1 offsite, immutability.

• Thực hành: Áp 3-2-1 cho dữ liệu quan trọng.

Ngày 158: Velero

• Mục tiêu: Backup k8s (nối Layer 4).

• Lý thuyết: Velero backup/restore, volume snapshot.

• Thực hành: Backup một namespace bằng Velero.

Ngày 159: Velero - scheduled & restore

• Mục tiêu: Backup tự động + phục hồi.

• Lý thuyết: schedule, restore, migration cluster.

• Thực hành: Scheduled backup + restore test.

Ngày 160: Application-consistent backup

• Mục tiêu: Backup nhất quán.

• Lý thuyết: quiesce, hooks, consistency (nối Layer 3).

• Thực hành: App-consistent backup cho DB.

Ngày 161: Data replication

• Mục tiêu: Đồng bộ dữ liệu (nối Layer 3).

• Lý thuyết: sync vs async replication, lag = RPO.

• Thực hành: Replicate dữ liệu cross-region.

Ngày 162: Database DR

• Mục tiêu: DR cho DB (nối Layer 3).

• Lý thuyết: replica, PITR, failover, WAL shipping.

• Thực hành: Failover một managed DB.

Ngày 163: Stateful workload DR

• Mục tiêu: DR cho stateful.

• Lý thuyết: StatefulSet + volume DR (nối Layer 4).

• Thực hành: DR cho một stateful app.

Ngày 164: Multi-region failover

• Mục tiêu: Chuyển vùng.

• Lý thuyết: failover region, data sync trước.

• Thực hành: Failover sang region khác.

Ngày 165: DNS/traffic failover

• Mục tiêu: Chuyển traffic (nối Layer 3/5).

• Lý thuyết: DNS failover, anycast, health-based routing.

• Thực hành: Failover traffic tự động.

Ngày 166: Failover automation

• Mục tiêu: Tự động chuyển.

• Lý thuyết: automated failover, split-brain risk.

• Thực hành: Automate failover có safeguard.

Ngày 167: DR testingdrills

• Mục tiêu: DR chưa test = không có DR.

• Lý thuyết: DR drill, tần suất, scope.

• Thực hành: Lập kế hoạch DR drill.

Ngày 168: DR runbook - cấu trúc

• Mục tiêu: Runbook phục hồi.

• Lý thuyết: step-by-step, roles, decision points.

• Thực hành: Cấu trúc DR runbook.

Ngày 169: Recovery validation

• Mục tiêu: Chắc chắn phục hồi đúng.

• Lý thuyết: validate data integrity + function sau restore.

• Thực hành: Validate sau một restore.

Ngày 170: Partial vs full DR

• Mục tiêu: DR theo mức.

• Lý thuyết: phục hồi từng phần, ưu tiên service.

• Thực hành: Ưu tiên phục hồi theo tier.

Ngày 171: DR cho data/AI

• Mục tiêu: DR data/AI (nối Layer 9/10).

• Lý thuyết: backup lakehouse/model registry.

• Thực hành: DR cho một data/AI platform.

Ngày 172: DR cost tradeoff

• Mục tiêu: DR đắt (nối Khối D).

• Lý thuyết: RTO/RPO thấp = chi phí cao.

• Thực hành: Chọn chiến lược DR theo cost.

Ngày 173: P6 - thiết kế DR

• Mục tiêu: Đóng khung phần DR của P6.

• Lý thuyết: RTO/RPO + strategy + backup + failover + runbook.

• Thực hách: dr-design.md.

Ngày 174: P6 - backup/restore + failover + drill

• Mục tiêu: DR chạy được.

• Lý thuyết: Velero backup + multi-region failover + drill.

• Thực hành: Backup + failover + DR drill; ghi kết quả.

KHỐI G - Platform Reliability Product capstone (Ngày 175-180) → P6 flagship

Ngày 175: P6 - DR runbook hoàn chỉnh

• Mục tiêu: Runbook dùng được.

• Lý thuyết: DR runbook + validation.

• Thực hành: DR runbook hoàn chỉnh + drill result.

Ngày 176: P6 - tích hợp

• Mục tiêu: Bundle đúng bản gốc.

• Lý thuyết: roadmap (P1) + SLO dashboard (P2) + chaos (P5) + DR runbook.

• Thực hành: Ghép thành Platform Reliability Product.

Ngày 177: P6 - reliability review

• Mục tiêu: Nhìn tổng độ tin cậy.

• Lý thuyết: SLO + error budget + incident trend (nối Khối B/C).

• Thực hành: Reliability review report.

Ngày 178: P6 - game-day validate SLO + DR

• Mục tiêu: Chứng minh cùng lúc.

• Lý thuyết: chaos + DR drill kiểm chứng SLO chịu được.

• Thực hành: Game-day kết hợp chaos + failover.

Ngày 179: P6 - product docs; ôn Layer 11

• Mục tiêu: Vận hành như sản phẩm.

• Lý thuyết: roadmap/RFC/runbook/dashboard như một sản phẩm (nối Layer 6); rà toàn layer.

• Thực hành: Bộ tài liệu Platform Reliability Product.

Ngày 180: HOÀN THÀNH LAYER 11

• Mục tiêu: Chốt Platform Product & Reliability ở mức Sâu.

• Lý thuyết: Ôn toàn layer; kiểm kê tổng: P1 roadmap + P2 SLO dashboard + P3 incident + P4 FinOps + P5 chaos + P6 Platform Reliability Product (roadmap + SLO + chaos + DR runbook).

• Thực hành: P6 done; đề thi #7 tích lũy (toàn layer) + tự chấm theo rubric; blog #116 ("Nhìn lại 180 ngày reliability: SLO, incident, FinOps, chaos, DR trong một Platform Reliability Product"); tag layer11-complete; nghỉ nửa ngày

LAYER 12 - RESEARCH LITERACY

Tài nguyên: How to Read a Paper (Keshav), MIT 6.824 reading list, Papers We Love, The Morning Paper (Adrian Colyer), ACM Artifact Review & Badging, các kỷ yếu SOSP/OSDI/NSDI/SIGCOMM/FAST/SIGMOD/VLDB/PLDI/ISCA/MICRO/USENIX Security/IEEE S&P.

KHỐI A - Cách đọc paper & Research Literacy (Ngày 1-18)

Ngày 1: Khởi động Layer 12

• Mục tiêu: Vì sao research literacy + cách chạy song song.

• Lý thuyết: đích: đọc & đóng góp được cho dự án nền tảng lớn (nối Layer 13).

• Thực hành: Repo research-literacy/; lập tracker 100 paper (bảng: paper/venue/layer/status/notes).

Ngày 2: How to read a paper - three-pass

• Mục tiêu: Phương pháp Keshav.

• Lý thuyết: ba lượt đọc, mục tiêu từng lượt.

• Thực hành: Áp three-pass lên một paper.

Ngày 3: First pass

• Mục tiêu: Nắm ý trong 10 phút.

• Lý thuyết: title/abstract/intro/headings/conclusions/skim.

• Thực hành: First-pass 3 paper; quyết định đọc sâu cái nào.

Ngày 4: Second pass

• Mục tiêu: Hiểu nội dung chính.

• Lý thuyết: figures/tables, main claims, method (bỏ chứng minh chi tiết).

• Thực hành: Second-pass một paper; tóm tắt 1 trang.

Ngày 5: Third pass

• Mục tiêu: Hiểu sâu như tự làm lại.

• Lý thuyết: re-implement trong đầu, tìm giả định ẩn, điểm yếu.

• Thực hành: Third-pass một paper quan trọng.

Ngày 6: Phê phán claim

• Mục tiêu: Không tin mù.

• Lý thuyết: evidence, baseline công bằng, threats to validity.

• Thực hành: Liệt kê điểm yếu của một paper.

Ngày 7: Hiểu phương pháp thực nghiệm

• Mục tiêu: Đọc phần eval đúng.

• Lý thuyết: setup, metric, so sánh, ý nghĩa thống kê (nối Khối C).

• Thực hành: Đánh giá eval của một paper.

Ngày 8: Paper systems vs theory

• Mục tiêu: Đọc đúng thể loại.

• Lý thuyết: systems (đo đạc) vs theory (chứng minh).

• Thực hành: So cách đọc hai thể loại.

Ngày 9: Hệ thống ghi chú

• Mục tiêu: Ghi để dùng lại.

• Lý thuyết: structured notes/Zettelkasten, template.

• Thực hành: Thiết lập template ghi chú paper.

Ngày 10: Literature map

• Mục tiêu: Nhìn bức tranh lớn.

• Lý thuyết: citation graph, cụm chủ đề.

• Thực hành: Vẽ literature map ban đầu.

Ngày 11: Tìm paper

• Mục tiêu: Biết nguồn.

• Lý thuyết: venue top, Google Scholar/arXiv/Semantic Scholar, dblp.

• Thực hành: Lập danh sách paper theo layer.

Ngày 12: Theo citation

• Mục tiêu: Đào sâu chủ đề.

• Lý thuyết: backward (references) vs forward (cited-by).

• Thực hành: Từ một paper, tìm 5 paper liên quan.

Ngày 13: Reading group

• Mục tiêu: Học cùng nhau.

• Lý thuyết: Papers We Love, thảo luận, đặt câu hỏi.

• Thực hành: Chuẩn bị trình bày một paper.

Ngày 14: Template review

• Mục tiêu: Ghi lại thứ đáng.

• Lý thuyết: problem/idea/method/eval/limitation/takeaway.

• Thực hành: Hoàn thiện template review.

Ngày 15: Seminal vs incremental

• Mục tiêu: Ưu tiên đọc.

• Lý thuyết: paper nền tảng vs cải tiến nhỏ.

• Thực hành: Phân loại một danh sách paper.

Ngày 16: Reproducibility & artifact

• Mục tiêu: Chuẩn bị tái hiện (nối Khối D).

• Lý thuyết: ACM badges (Available/Functional/Reproduced), artifact eval.

• Thực hành: Tìm paper có artifact tốt để tái hiện.

Ngày 17: P1 - hệ thống đọc + tracker

• Mục tiêu: Đóng khung P1.

• Lý thuyết: workflow: tìm → three-pass → note → map.

• Thực hành: Tracker + template + literature map khởi động.

Ngày 18: P1 - bắt đầu 100 paper

• Mục tiêu: Đọc những paper nền tảng đầu tiên.

• Lý thuyết: chọn 10-15 paper kinh điển đọc trước.

• Thực hành: Review các paper đầu; cập nhật tracker.

KHỐI B - Domain Paper Deep-Dives (Ngày 19-78)

Ngày 19: Systems/OS - venue

• Mục tiêu: Bản đồ SOSP/OSDI.

• Lý thuyết: chủ đề, cách chọn paper.

• Thực hành: Danh sách OS/systems papers cần đọc.

Ngày 20: GFS

• Mục tiêu: Distributed file system kinh điển.

• Lý thuyết: "The Google File System" - design cho commodity + fault.

• Thực hành: Review + note (nối Layer 3).

Ngày 21: MapReduce

• Mục tiêu: Mô hình xử lý lớn.

• Lý thuyết: map/reduce, fault tolerance.

• Thực hành: Review + note (nối Layer 9).

Ngày 22: Bigtable

• Mục tiêu: Wide-column store.

• Lý thuyết: SSTable, tablet, LSM (nối Layer 3).

• Thực hành: Review + note.

Ngày 23: Dynamo

• Mục tiêu: Eventual consistency + availability.

• Lý thuyết: consistent hashing, vector clock, quorum.

• Thực hành: Review + note (nối Layer 3).

Ngày 24: Spanner

• Mục tiêu: Global consistency.

• Lý thuyết: TrueTime, external consistency (nối Layer 3).

• Thực hành: Review + note.

Ngày 25: Paxos

• Mục tiêu: Consensus nền tảng.

• Lý thuyết: "Paxos Made Simple".

• Thực hành: Review + note.

Ngày 26: Raft

• Mục tiêu: Consensus dễ hiểu.

• Lý thuyết: leader election, log replication (nối Layer 3/4).

• Thực hành: Review + note.

Ngày 27: ZooKeeper/Chubby

• Mục tiêu: Coordination service.

• Lý thuyết: lock/coordination, wait-free (nối Layer 4 etcd).

• Thực hành: Review + note.

Ngày 28: Borg/Kubernetes

• Mục tiêu: Cluster management.

• Lý thuyết: Borg/Omega, lessons → Kubernetes (nối Layer 4).

• Thực hành: Review + note.

Ngày 29: Dapper

• Mục tiêu: Distributed tracing.

• Lý thuyết: trace/span, sampling (nối Layer 7).

• Thực hành: Review + note.

Ngày 30: CỘT MỐC 30

• Mục tiêu: Chốt phương pháp + 20 paper đầu.

• Lý thuyết: Ôn A + đầu B; kiểm kê: hệ thống đọc + 20 paper có note.

• Thực hành: P1 done (20 paper); đề thi #1 (phương pháp đọc + tóm tắt 3 paper) + tự chấm; blog #117 ("Cách đọc và phê phán một systems paper: three-pass và literature map"); tag layer12-day030; nghỉ nửa ngày. Đã đi 30/120 (25%).

Ngày 31: End-to-End Arguments

• Mục tiêu: Nguyên lý thiết kế.

• Lý thuyết: đặt chức năng ở đâu trong hệ.

• Thực hành: Review + note.

Ngày 32: Hints for System Design

• Mục tiêu: Trí tuệ thiết kế (Lampson).

• Lý thuyết: các hint kinh điển.

• Thực hành: Review + rút hint áp dụng được.

Ngày 33: Virtualization

• Mục tiêu: Xen/Firecracker.

• Lý thuyết: paravirtualization, microVM (nối Layer 2).

• Thực hành: Review + note.

Ngày 34: gVisor

• Mục tiêu: Userspace kernel sandbox.

• Lý thuyết: Sentry, syscall interception (nối Layer 2).

• Thực hành: Review + note.

Ngày 35: Microkernel (L4/seL4)

• Mục tiêu: Kiến trúc OS khác.

• Lý thuyết: microkernel, seL4 (verified).

• Thực hành: Review + note.

Ngày 36: Scheduling

• Mục tiêu: Nền lập lịch.

• Lý thuyết: scheduler activations, EEVDF background (nối Layer 2).

• Thực hành: Review + note.

Ngày 37: Networks - venue

• Mục tiêu: Bản đồ NSDI/SIGCOMM.

• Lý thuyết: chủ đề networking research.

• Thực hành: Danh sách networking papers.

Ngày 38: BBR

• Mục tiêu: Congestion control hiện đại.

• Lý thuyết: model-based (nối Layer 3).

• Thực hành: Review + note.

Ngày 39: Maglev

• Mục tiêu: L4 load balancer.

• Lý thuyết: consistent hashing, packet processing (nối Layer 3).

• Thực hành: Review + note.

Ngày 40: B4/Jupiter

• Mục tiêu: DC/WAN networking.

• Lý thuyết: SDN WAN (B4), DC fabric (Jupiter, nối Layer 3).

• Thực hành: Review + note.

Ngày 41: DCTCP

• Mục tiêu: DC congestion.

• Lý thuyết: ECN-based, low latency.

• Thực hành: Review + note.

Ngày 42: Storage - venue (FAST)

• Mục tiêu: Bản đồ FAST.

• Lý thuyết: storage systems research.

• Thực hành: Danh sách storage papers.

Ngày 43: LFS

• Mục tiêu: Log-structured FS.

• Lý thuyết: write-optimized, cleaning (nối Layer 3).

• Thực hành: Review + note.

Ngày 44: LSM/WiscKey

• Mục tiêu: LSM tree sâu.

• Lý thuyết: LSM, key-value separation (nối Layer 3).

• Thực hành: Review + note.

Ngày 45: Haystack/Ceph

• Mục tiêu: Object/distributed storage.

• Lý thuyết: Haystack (photos), Ceph/CRUSH (nối Layer 3).

• Thực hành: Review + note.

Ngày 46: Data - venue (SIGMOD/VLDB)

• Mục tiêu: Bản đồ database research.

• Lý thuyết: OLTP/OLAP/distributed data.

• Thực hành: Danh sách data papers.

Ngày 47: C-Store

• Mục tiêu: Column store.

• Lý thuyết: columnar, projection (nối Layer 3/9).

• Thực hành: Review + note.

Ngày 48: MonetDB/X100

• Mục tiêu: Vectorized execution.

• Lý thuyết: vectorized processing (nối Layer 3/9).

• Thực hành: Review + note.

Ngày 49: Percolator

• Mục tiêu: Distributed transactions.

• Lý thuyết: snapshot isolation trên KV (nối Layer 3).

• Thực hành: Review + note.

Ngày 50: Dremel

• Mục tiêu: Interactive analytics.

• Lý thuyết: columnar + tree execution (nối Layer 9).

• Thực hành: Review + note.

Ngày 51: Spark RDD

• Mục tiêu: In-memory cluster computing.

• Lý thuyết: RDD, lineage (nối Layer 9).

• Thực hành: Review + note.

Ngày 52: Dataflow Model

• Mục tiêu: Streaming lý thuyết.

• Lý thuyết: event/processing time, watermark (nối Layer 9).

• Thực hành: Review + note.

Ngày 53: Aurora

• Mục tiêu: Cloud DB, tách storage-compute.

• Lý thuyết: log-as-database (nối Layer 3/9).

• Thực hành: Review + note.

Ngày 54: Snowflake

• Mục tiêu: Cloud warehouse.

• Lý thuyết: tách compute/storage, elastic (nối Layer 9).

• Thực hành: Review + note.

Ngày 55: PL - venue (PLDI/POPL)

• Mục tiêu: Bản đồ PL research.

• Lý thuyết: compiler/type/verification.

• Thực hành: Danh sách PL papers.

Ngày 56: LLVM

• Mục tiêu: Compiler infrastructure.

• Lý thuyết: IR, pass (nối Layer 1).

• Thực hành: Review + note.

Ngày 57: SSA/CompCert

• Mục tiêu: IR & verified compiler.

• Lý thuyết: SSA form, CompCert (verified, nối Layer 1).

• Thực hành: Review + note.

Ngày 58: Rust/RustBelt

• Mục tiêu: Ownership & safety.

• Lý thuyết: ownership, borrow, RustBelt proof (nối Layer 0/1).

• Thực hành: Review + note.

Ngày 59: Architecture - venue (ISCA/MICRO)

• Mục tiêu: Bản đồ architecture research.

• Lý thuyết: CPU/GPU/accelerator.

• Thực hành: Danh sách architecture papers.

Ngày 60: CỘT MỐC 60

• Mục tiêu: Chốt 50 paper + literature map.

• Lý thuyết: Ôn B tới giờ; kiểm kê: 50 paper có note + map nhiều domain.

• Thực hành: P2 done (50 paper); đề thi #2 (tổng hợp cross-domain) + tự chấm; blog #118 ("50 paper nền tảng: từ GFS/Raft tới Dataflow và LLVM"); tag layer12-day060; nghỉ nửa ngày. Đã đi 60/120 (50%).

Ngày 61: TPU

• Mục tiêu: Accelerator cho ML.

• Lý thuyết: systolic array (nối Layer 10).

• Thực hành: Review + note.

Ngày 62: Cache coherence

• Mục tiêu: Memory consistency.

• Lý thuyết: coherence protocol, consistency model (nối Layer 0).

• Thực hành: Review + note.

Ngày 63: Branch prediction/OoO

• Mục tiêu: Micro-architecture.

• Lý thuyết: speculation, out-of-order (nối Layer 0).

• Thực hành: Review + note.

Ngày 64: GPU architecture

• Mục tiêu: Song song hoá lớn.

• Lý thuyết: SIMT, memory (nối Layer 0/10).

• Thực hành: Review + note.

Ngày 65: Security - venue (USENIX/S&P)

• Mục tiêu: Bản đồ security research.

• Lý thuyết: attack/defense, side channels.

• Thực hành: Danh sách security papers.

Ngày 66: Meltdown

• Mục tiêu: Micro-arch side channel.

• Lý thuyết: out-of-order leak (nối Layer 0/8).

• Thực hành: Review + note.

Ngày 67: Spectre

• Mục tiêu: Speculation attack.

• Lý thuyết: branch speculation leak (nối Layer 0/8).

• Thực hành: Review + note.

Ngày 68: Rowhammer

• Mục tiêu: Hardware bit-flip.

• Lý thuyết: DRAM disturbance.

• Thực hành: Review + note.

Ngày 69: SGX/confidential computing

• Mục tiêu: Trusted execution.

• Lý thuyết: enclave, attestation (nối Layer 8).

• Thực hành: Review + note.

Ngày 70: CFI/ROP

• Mục tiêu: Control-flow attacks/defense.

• Lý thuyết: ROP, Control-Flow Integrity.

• Thực hành: Review + note.

Ngày 71: DeepSpeed/ZeRO

• Mục tiêu: Training bộ nhớ hiệu quả.

• Lý thuyết: ZeRO partitioning (nối Layer 10).

• Thực hành: Review + note.

Ngày 72: Megatron/FSDP

• Mục tiêu: Model parallelism.

• Lý thuyết: tensor/pipeline parallel, FSDP (nối Layer 10).

• Thực hành: Review + note.

Ngày 73: PagedAttention/vLLM

• Mục tiêu: LLM serving hiệu quả.

• Lý thuyết: KV cache paging (nối Layer 10).

• Thực hành: Review + note.

Ngày 74: Observability research

• Mục tiêu: Nền quan sát.

• Lý thuyết: tracing/OpenTelemetry background (nối Layer 7).

• Thực hành: Review + note.

Ngày 75: Reliability/SRE

• Mục tiêu: Nền reliability.

• Lý thuyết: SLO/error budget, Google SRE (nối Layer 11).

• Thực hành: Review + note.

Ngày 76: Đọc survey

• Mục tiêu: Nắm nhanh một lĩnh vực.

• Lý thuyết: survey structure, dùng để định hướng.

• Thực hành: Đọc một survey; rút reading list.

Ngày 77: Tổng hợp cross-paper

• Mục tiêu: Nối các paper thành chủ đề.

• Lý thuyết: thematic synthesis, so sánh cách tiếp cận.

• Thực hành: Note tổng hợp một chủ đề (ví dụ consensus).

Ngày 78: Literature map hoàn chỉnh

• Mục tiêu: Bức tranh 75+ paper.

• Lý thuyết: map theo domain + cluster.

• Thực hành: Cập nhật map (đã ~75 paper).

KHỐI C - Benchmark Methodology (Ngày 79-90) → P3

Ngày 79: Vì sao benchmark

• Mục tiêu: So sánh công bằng.

• Lý thuyết: benchmark tốt vs "benchmark crime".

• Thực hành: Liệt kê bẫy benchmark hay gặp.

Ngày 80: Nguyên tắc thiết kế

• Mục tiêu: Benchmark có ý nghĩa.

• Lý thuyết: representative workload, fair baseline, reproducible.

• Thực hành: Phác một benchmark cho một hệ.

Ngày 81: SPEC

• Mục tiêu: CPU/system benchmark chuẩn.

• Lý thuyết: SPEC CPU (nối Layer 0).

• Thực hành: Đọc phương pháp SPEC.

Ngày 82: TPC

• Mục tiêu: Database benchmark.

• Lý thuyết: TPC-C (OLTP), TPC-H/DS (OLAP) (nối Layer 3/9).

• Thực hách: Đọc + hiểu TPC workload.

Ngày 83: YCSB

• Mục tiêu: KV/NoSQL benchmark.

• Lý thuyết: workload A-F, read/write mix (nối Layer 3).

• Thực hành: Áp YCSB cho một KV store.

Ngày 84: CloudSuite/MLPerf

• Mục tiêu: Cloud & ML benchmark.

• Lý thuyết: CloudSuite (cloud workloads), MLPerf (nối Layer 10).

• Thực hành: Đọc phương pháp MLPerf.

Ngày 85: Micro vs macro

• Mục tiêu: Chọn mức đo.

• Lý thuyết: microbenchmark (thành phần) vs macro (hệ).

• Thực hành: Thiết kế cả hai cho một hệ.

Ngày 86: Rigor thống kê

• Mục tiêu: Số liệu đáng tin.

• Lý thuyết: variance, confidence interval, đủ số lần chạy.

• Thực hành: Chạy nhiều lần + tính CI.

Ngày 87: Đo latency đúng

• Mục tiêu: Không lừa mình.

• Lý thuyết: percentile, coordinated omission (nối Layer 7).

• Thực hành: Đo latency tránh coordinated omission.

Ngày 88: Đo throughput + benchmark crimes

• Mục tiêu: Trung thực.

• Lý thuyết: throughput đúng, các "benchmark crime" kinh điển.

• Thực hành: Rà một benchmark tìm lỗi.

Ngày 89: Reproducible benchmark + P3 design

• Mục tiêu: Đóng khung P3.

• Lý thuyết: kiểm soát môi trường (container, nối Layer 4), pin version.

• Thực hách: benchmark-study-design.md.

Ngày 90: CỘT MỐC 90

• Mục tiêu: Chốt benchmark; release P3.

• Lý thuyết: Ôn C; kiểm kê: benchmark study đúng phương pháp + rigor thống kê.

• Thực hành: P3 done (benchmark study report); đề thi #3 (benchmark methodology) + tự chấm; blog #119 ("Benchmark cho ra hồn: percentile, coordinated omission, và tránh benchmark crime"); tag layer12-day090; nghỉ nửa ngày. Đã đi 90/120 (75%).

KHỐI D - Reproduction Practice (Ngày 91-114) → P4 (tái hiện 5)

Ngày 91: Tái hiện - vì sao

• Mục tiêu: Học sâu nhất bằng làm lại.

• Lý thuyết: reproduction vs replication, artifact evaluation.

• Thực hành: Chọn 5 paper có thể tái hiện.

Ngày 92: Chọn paper tái hiện

• Mục tiêu: Khả thi & giá trị.

• Lý thuyết: tiêu chí: artifact, scope, tài nguyên.

• Thực hành: Chốt 5 paper + kế hoạch.

Ngày 93: Dựng môi trường

• Mục tiêu: Tái lập được (nối Layer 4).

• Lý thuyết: container hoá, pin dependency, ghi env.

• Thực hành: Template môi trường tái hiện.

Ngày 94: Tái hiện 1 - setup (storage)

• Mục tiêu: Paper storage/LSM (nối Layer 3).

• Lý thuyết: đọc kỹ eval để lặp lại.

• Thực hành: Setup + chạy thử.

Ngày 95: Tái hiện 1 - chạy

• Mục tiêu: Ra số.

• Lý thuyết: chạy experiment chính.

• Thực hành: Thu số liệu.

Ngày 96: Tái hiện 1 - so sánh + writeup

• Mục tiêu: Đối chiếu paper.

• Lý thuyết: khớp/không khớp, giải thích.

• Thực hành: Reproduction report #1.

Ngày 97: Tái hiện 2 - setup (OS/scheduling)

• Mục tiêu: Paper OS (nối Layer 2).

• Lý thuyết: đo scheduling/latency.

• Thực hành: Setup + chạy thử.

Ngày 98: Tái hiện 2 - chạy

• Mục tiêu: Thu số.

• Lý thuyết: experiment chính.

• Thực hành: Thu số liệu.

Ngày 99: Tái hiện 2 - writeup

• Mục tiêu: Báo cáo.

• Lý thuyết: so sánh + phân tích.

• Thực hành: Reproduction report #2.

Ngày 100:

• Mục tiêu: Kiểm kê lớn giữa Layer 12.

• Lý thuyết: Ôn A→C + đầu D; kiểm kê lớn: ~85 paper có note + benchmark report + 2 tái hiện; đối chiếu năng lực research literacy.

• Thực hành: Đề thi #4 tích lũy (đọc + benchmark + tái hiện) + tự chấm theo rubric; blog #120 ("Tái hiện paper: khi số của bạn không khớp số của họ"); tag layer12-day100; nghỉ nửa ngày. Đã đi 100/120 (83%).

Ngày 101: Tái hiện 3 - setup (networking)

• Mục tiêu: Paper networking (nối Layer 3).

• Lý thuyết: đo congestion/latency.

• Thực hành: Setup + chạy thử.

Ngày 102: Tái hiện 3 - chạy

• Mục tiêu: Thu số.

• Lý thuyết: experiment chính.

• Thực hành: Thu số liệu.

Ngày 103: Tái hiện 3 - writeup

• Mục tiêu: Báo cáo.

• Lý thuyết: so sánh.

• Thực hành: Reproduction report #3.

Ngày 104: Tái hiện 4 - setup (data/query)

• Mục tiêu: Paper data (nối Layer 9).

• Lý thuyết: đo query/throughput.

• Thực hành: Setup + chạy thử.

Ngày 105: Tái hiện 4 - chạy

• Mục tiêu: Thu số.

• Lý thuyết: experiment chính.

• Thực hành: Thu số liệu.

Ngày 106: Tái hiện 4 - writeup

• Mục tiêu: Báo cáo.

• Lý thuyết: so sánh.

• Thực hành: Reproduction report #4.

Ngày 107: Tái hiện 5 - setup (ML systems)

• Mục tiêu: Paper ML systems (nối Layer 10).

• Lý thuyết: đo training/serving.

• Thực hành: Setup + chạy thử.

Ngày 108: Tái hiện 5 - chạy

• Mục tiêu: Thu số.

• Lý thuyết: experiment chính.

• Thực hành: Thu số liệu.

Ngày 109: Tái hiện 5 - writeup

• Mục tiêu: Báo cáo.

• Lý thuyết: so sánh.

• Thực hành: Reproduction report #5.

Ngày 110: Khi không tái hiện được

• Mục tiêu: Đối mặt thất bại.

• Lý thuyết: lý do không repro (env, thiếu chi tiết, artifact hỏng).

• Thực hành: Ghi lại một trường hợp không repro.

Ngày 111: Báo cáo kết quả âm trung thực

• Mục tiêu: Khoa học tử tế.

• Lý thuyết: negative result cũng có giá trị.

• Thực hành: Viết negative result rõ ràng.

Ngày 112: Ráp portfolio tái hiện

• Mục tiêu: Gom lại.

• Lý thuyết: 5 reproduction report + artifact.

• Thực hành: Portfolio tái hiện.

Ngày 113: P4 - hoàn thiện report

• Mục tiêu: Chất lượng.

• Lý thuyết: rà rõ ràng, có số, có phân tích.

• Thực hành: Polish 5 report.

Ngày 114: P4 - 5 tái hiện

• Mục tiêu: Release P4.

• Lý thuyết: rà "done": 5 reproduction report + artifact công khai.

• Thực hành: Đóng gói + blog #121 ("Portfolio tái hiện 5 paper: từ storage tới ML systems"). P4 done.

KHỐI E - Technical Writing (Ngày 115-120) → P5 flagship

Ngày 115: Technical writing - cấu trúc

• Mục tiêu: Viết report rõ ràng.

• Lý thuyết: problem → approach → result → discussion.

• Thực hành: Outline một technical report.

Ngày 116: Viết reproduction report

• Mục tiêu: Báo cáo tái hiện chuẩn.

• Lý thuyết: method, setup, result, discrepancy analysis.

• Thực hành: Chuẩn hoá 5 report theo cấu trúc.

Ngày 117: Viết survey/synthesis

• Mục tiêu: Tổng hợp một lĩnh vực.

• Lý thuyết: survey structure, so sánh cách tiếp cận, taxonomy.

• Thực hành: Draft một survey ngắn từ note đã có.

Ngày 118: P5 - portfolio 100 paper + survey

• Mục tiêu: Đóng khung flagship.

• Lý thuyết: 100 paper có note + literature map + một survey report.

• Thực hành: Hoàn tất 100 paper; viết survey report.

Ngày 119: P5 - hoàn thiện; ôn Layer 12

• Mục tiêu: Chốt portfolio.

• Lý thuyết: rà 100 note + 5 tái hiện + benchmark + survey.

• Thực hành: Xuất bản portfolio; rà toàn layer.

Ngày 120: HOÀN THÀNH LAYER 12

• Mục tiêu: Chốt Research Literacy.

• Lý thuyết: Ôn toàn layer; kiểm kê tổng: P1 hệ thống đọc + P2 50 paper + P3 benchmark report + P4 5 tái hiện + P5 100-paper portfolio + survey report.

• Thực hành: P5 done; đề thi #5 tích lũy (đọc/phê phán/tái hiện/viết) + tự chấm theo rubric; blog #122 ("Nhìn lại Research Literacy: đọc 100 paper, tái hiện 5, và viết được technical report"); tag layer12-complete; nghỉ nửa ngày.

LAYER 13 - SOURCE CODE READING & CONTRIBUTION (Syllabus chi tiết theo ngày)

Tài nguyên: CONTRIBUTING.md của từng dự án, GitHub Open Source Guides, Linux Documentation/process/, Working in Public (Nadia Eghbal), LWN.net, talk của maintainer, Sourcegraph/GitHub code search.

KHỐI A - Code Reading Skills (Ngày 1-30) → P1

Ngày 1: Khởi động Layer 13

• Mục tiêu: Vì sao đọc & đóng góp OSS + cách chạy song song.

• Lý thuyết: đọc source ≠ đọc doc; đích: contribute được.

• Thực hành: Repo oss-contrib/; lập tracker (project/domain/status/PR).

Ngày 2: Định hướng codebase

• Mục tiêu: Vào một repo lạ không hoảng.

• Lý thuyết: README, ARCHITECTURE.md, docs/, DESIGN.

• Thực hành: Đọc "map" của một dự án lớn.

Ngày 3: Cấu trúc & build

• Mục tiêu: Build được để đọc.

• Lý thuyết: directory layout, build system, dev setup.

• Thực hành: Clone + build một dự án từ source.

Ngày 4: ctags/cscope

• Mục tiêu: Nhảy trong code.

• Lý thuyết: symbol index, jump-to-definition.

• Thực hành: Index một codebase; tra một hàm.

Ngày 5: LSP & IDE

• Mục tiêu: Navigation hiện đại.

• Lý thuyết: clangd/gopls/rust-analyzer, go-to-def, find-references.

• Thực hành: Duyệt call graph bằng LSP.

Ngày 6: Code search

• Mục tiêu: Tìm nhanh.

• Lý thuyết: Sourcegraph, GitHub code search, ripgrep.

• Thực hành: Tìm nơi một khái niệm được cài đặt.

Ngày 7: git blame/log

• Mục tiêu: Hiểu vì sao code thế này.

• Lý thuyết: blame, log, đọc commit message.

• Thực hành: Truy một dòng code về commit gốc.

Ngày 8: git bisect

• Mục tiêu: Tìm thay đổi gây điều gì đó.

• Lý thuyết: bisect để định vị commit.

• Thực hành: Bisect một thay đổi hành vi.

Ngày 9: Top-down reading

• Mục tiêu: Từ entry point đi xuống.

• Lý thuyết: main → khởi tạo → subsystem.

• Thực hành: Theo entry point một dự án.

Ngày 10: Bottom-up reading

• Mục tiêu: Từ data structure lên.

• Lý thuyết: cấu trúc dữ liệu lõi → cách dùng.

• Thực hành: Đọc struct chính + nơi dùng.

Ngày 11: Following an operation

• Mục tiêu: Đi trọn một thao tác.

• Lý thuyết: trace một request/operation end-to-end.

• Thực hành: Theo một operation xuyên các module.

Ngày 12: Đọc test

• Mục tiêu: Hiểu hành vi qua test.

• Lý thuyết: test = đặc tả sống.

• Thực hành: Đọc test suite của một module.

Ngày 13: Debug để trace

• Mục tiêu: Chạy để hiểu.

• Lý thuyết: breakpoint, step, print (nối Layer 2 gdb).

• Thực hành: Debug một luồng để hiểu.

Ngày 14: Reconstructing architecture

• Mục tiêu: Dựng lại bức tranh.

• Lý thuyết: module boundary, abstraction, dependency.

• Thực hành: Vẽ architecture từ code đọc được.

Ngày 15: Control vs data flow

• Mục tiêu: Hai chiều nhìn.

• Lý thuyết: control flow vs data flow.

• Thực hành: Vẽ cả hai cho một tính năng.

Ngày 16: Đọc commit/PR history

• Mục tiêu: Học từ lịch sử.

• Lý thuyết: đọc PR lớn, hiểu quyết định.

• Thực hành: Đọc một PR quan trọng của dự án.

Ngày 17: Đọc RFC/design docs

• Mục tiêu: Hiểu "vì sao".

• Lý thuyết: design doc, proposal, KEP (Kubernetes).

• Thực hành: Đọc một design doc; tóm tắt.

Ngày 18: Note-taking cho codebase

• Mục tiêu: Ghi để dùng lại.

• Lý thuyết: khác note paper; map function/flow.

• Thực hành: Template note codebase.

Ngày 19: Diagram từ code

• Mục tiêu: Trực quan hoá.

• Lý thuyết: vẽ module/sequence từ code.

• Thực hành: Diagram một subsystem.

Ngày 20: Key abstraction & hot path

• Mục tiêu: Tìm phần quan trọng nhất.

• Lý thuyết: abstraction lõi, hot path.

• Thực hành: Xác định hot path một dự án.

Ngày 21: Đọc code hiệu năng

• Mục tiêu: Nối profiling (nối Layer 7).

• Lý thuyết: đọc code + profile để hiểu bottleneck.

• Thực hành: Profile + đọc hot function.

Ngày 22: Đọc code bảo mật

• Mục tiêu: Nối security (nối Layer 8).

• Lý thuyết: đọc tìm điểm yếu, input validation.

• Thực hành: Rà một đường input.

Ngày 23: Chọn codebase

• Mục tiêu: Đọc theo layer đã học.

• Lý thuyết: map dự án ↔ layer (kernel↔L2, PG↔L3, k8s↔L4...).

• Thực hành: Chọn 2 codebase để đọc kỹ.

Ngày 24: Governance của OSS

• Mục tiêu: Hiểu cách dự án vận hành.

• Lý thuyết: maintainer, SIG, foundation (CNCF/Linux), roadmap.

• Thực hành: Đọc governance của một dự án.

Ngày 25: P1 - toolkit

• Mục tiêu: Đóng khung P1.

• Lý thuyết: LSP + search + note workflow.

• Thực hách: Setup toolkit + template.

Ngày 26: P1 - codebase 1 orient

• Mục tiêu: Định hướng dự án 1.

• Lý thuyết: build + architecture map.

• Thực hành: Build + đọc architecture dự án 1.

Ngày 27: P1 - codebase 1 deep

• Mục tiêu: Đọc sâu một subsystem.

• Lý thuyết: theo một operation end-to-end.

• Thực hành: Note + diagram subsystem.

Ngày 28: P1 - codebase 2 orient

• Mục tiêu: Định hướng dự án 2.

• Lý thuyết: build + architecture map.

• Thực hành: Build + đọc architecture dự án 2.

Ngày 29: P1 - architecture notes

• Mục tiêu: Ghi lại cả hai.

• Lý thuyết: architecture doc cho 2 dự án.

• Thực hành: Hoàn thiện note + diagram.

Ngày 30: CỘT MỐC 30

• Mục tiêu: Chốt kỹ năng đọc; release P1.

• Lý thuyết: Ôn A; kiểm kê: toolkit + đọc được 2 codebase lớn.

• Thực hành: P1 done; đề thi #1 (đọc + tóm tắt architecture một dự án) + tự chấm; blog #123 ("Cách đọc một codebase khổng lồ: LSP, following an operation, dựng lại architecture"); tag layer13-day030; nghỉ nửa ngày. Đã đi 30/120 (25%).

KHỐI B - Domain Code Deep-Dives (Ngày 31-72) → P2

Ngày 31: Linux kernel - orient

• Mục tiêu: Codebase OS lớn nhất (nối Layer 2).

• Lý thuyết: cây source, subsystem, Documentation/.

• Thực hành: Định vị một subsystem (đã biết từ Layer 2).

Ngày 32: Linux - đọc subsystem

• Mục tiêu: Đọc sâu một phần.

• Lý thuyết: ví dụ scheduler/driver/fs.

• Thực hành: Theo một syscall/đường đi.

Ngày 33: Linux - process cộng đồng

• Mục tiêu: Cách kernel vận hành.

• Lý thuyết: mailing list, patch, maintainer, LWN.

• Thực hành: Đọc một thread thảo luận patch.

Ngày 34: systemd

• Mục tiêu: Init system phức tạp.

• Lý thuyết: unit, dependency, cgroup (nối Layer 2).

• Thực hành: Đọc một phần systemd.

Ngày 35: LLVM - orient

• Mục tiêu: Compiler infra (nối Layer 1).

• Lý thuyết: IR, pass pipeline.

• Thực hành: Định vị một pass.

Ngày 36: LLVM - đọc một pass

• Mục tiêu: Hiểu một optimization.

• Lý thuyết: pass structure, IR transform.

• Thực hành: Đọc + trace một pass.

Ngày 37: Go runtime

• Mục tiêu: Runtime ngôn ngữ (nối Layer 1).

• Lý thuyết: scheduler (GMP), GC.

• Thực hành: Đọc scheduler hoặc GC Go.

Ngày 38: Wasmtime/WasmEdge

• Mục tiêu: WASM runtime (nối Layer 1).

• Lý thuyết: execution, JIT.

• Thực hành: Đọc một phần runtime WASM.

Ngày 39: PostgreSQL - orient

• Mục tiêu: RDBMS kinh điển (nối Layer 3).

• Lý thuyết: planner/executor/storage.

• Thực hành: Định vị executor.

Ngày 40: PostgreSQL - executor/planner

• Mục tiêu: Đọc một operator.

• Lý thuyết: Volcano model, node.

• Thực hành: Đọc seq scan/hash join (đã học Layer 3).

Ngày 41: RocksDB

• Mục tiêu: LSM thực chiến (nối Layer 3).

• Lý thuyết: compaction, memtable, SST.

• Thực hành: Đọc compaction code.

Ngày 42: ClickHouse/DuckDB/TiKV

• Mục tiêu: OLAP & distributed KV (nối Layer 3/9).

• Lý thuyết: MergeTree/vectorized/Raft.

• Thực hành: Đọc một phần của một trong ba.

Ngày 43: Envoy - orient

• Mục tiêu: Proxy nền tảng (nối Layer 4).

• Lý thuyết: listener/filter/cluster, xDS.

• Thực hành: Định vị filter chain.

Ngày 44: Envoy - đọc filter/xDS

• Mục tiêu: Hiểu xử lý request.

• Lý thuyết: HTTP filter, xDS config.

• Thực hành: Đọc một filter (đã học Layer 4).

Ngày 45: Cilium

• Mục tiêu: eBPF networking (nối Layer 2/4).

• Lý thuyết: eBPF datapath, agent.

• Thực hành: Đọc một phần datapath.

Ngày 46: Open vSwitch

• Mục tiêu: Virtual switch (nối Layer 3).

• Lý thuyết: flow table, datapath.

• Thực hành: Đọc một phần OVS.

Ngày 47: runc - orient

• Mục tiêu: Container runtime (nối Layer 2/4).

• Lý thuyết: libcontainer, ns/cgroups.

• Thực hành: Định vị container lifecycle.

Ngày 48: runc - lifecycle

• Mục tiêu: create/start/kill.

• Lý thuyết: OCI runtime-spec code (đã học Layer 4).

• Thực hành: Đọc create → start.

Ngày 49: containerd/BuildKit/Moby

• Mục tiêu: Runtime cấp cao (nối Layer 4).

• Lý thuyết: shim, snapshotter, build.

• Thực hành: Đọc một phần containerd/BuildKit.

Ngày 50: Kubernetes - orient

• Mục tiêu: Hệ sinh thái lớn nhất (nối Layer 4).

• Lý thuyết: apiserver/controller/kubelet, SIG structure.

• Thực hành: Định vị một controller.

Ngày 51: Kubernetes - đọc controller

• Mục tiêu: Reconciliation thực tế.

• Lý thuyết: informer/workqueue/reconcile (đã học Layer 4).

• Thực hành: Đọc một built-in controller.

Ngày 52: etcd - raft

• Mục tiêu: Consensus thực chiến (nối Layer 3/4).

• Lý thuyết: raft implementation.

• Thực hành: Đọc raft state machine etcd.

Ngày 53: Argo CD/Crossplane

• Mục tiêu: GitOps & platform (nối Layer 4/6).

• Lý thuyết: sync/reconcile, XRD.

• Thực hành: Đọc một phần Argo/Crossplane.

Ngày 54: Istio/KCP

• Mục tiêu: Mesh & control plane (nối Layer 4).

• Lý thuyết: istiod, xDS; KCP workspace.

• Thực hành: Đọc một phần Istio/KCP.

Ngày 55: Prometheus - orient

• Mục tiêu: Metrics engine (nối Layer 7).

• Lý thuyết: scrape, TSDB, PromQL.

• Thực hành: Định vị TSDB/scrape.

Ngày 56: Prometheus - TSDB/scrape

• Mục tiêu: Đọc storage/ingest.

• Lý thuyết: head/block, WAL (đã học Layer 3/7).

• Thực hành: Đọc scrape hoặc TSDB.

Ngày 57: OpenTelemetry Collector

• Mục tiêu: Pipeline observability (nối Layer 7).

• Lý thuyết: receiver/processor/exporter.

• Thực hành: Đọc một processor.

Ngày 58: Loki/Tempo/VictoriaMetrics

• Mục tiêu: Logs/traces/metrics khác (nối Layer 7).

• Lý thuyết: kiến trúc từng cái.

• Thực hành: Đọc một phần của một trong ba.

Ngày 59: Kafka - orient

• Mục tiêu: Streaming (nối Layer 9).

• Lý thuyết: log, partition, replication.

• Thực hành: Định vị log/replication.

Ngày 60: CỘT MỐC 60

• Mục tiêu: Chốt deep subsystem; release P2.

• Lý thuyết: Ôn B tới giờ; kiểm kê: đọc sâu một subsystem + architecture doc dựng lại.

• Thực hành: P2 done (subsystem architecture doc); đề thi #2 (giải thích một subsystem đã đọc) + tự chấm; blog #124 ("Dựng lại kiến trúc một subsystem thật: từ code tới sơ đồ"); tag layer13-day060; nghỉ nửa ngày. Đã đi 60/120 (50%).

Ngày 61: Kafka - component

• Mục tiêu: Đọc sâu một phần.

• Lý thuyết: log/replication/consumer group.

• Thực hành: Đọc một component Kafka.

Ngày 62: Iceberg

• Mục tiêu: Table format code (nối Layer 9).

• Lý thuyết: metadata/manifest, snapshot.

• Thực hành: Đọc metadata handling.

Ngày 63: Airflow/MLflow

• Mục tiêu: Orchestration & ML (nối Layer 9/10).

• Lý thuyết: DAG/scheduler; tracking/registry.

• Thực hành: Đọc một phần.

Ngày 64: Patterns across projects

• Mục tiêu: Nhận ra mẫu chung.

• Lý thuyết: plugin, reconcile, pipeline lặp lại nhiều nơi.

• Thực hành: Bảng pattern chung.

Ngày 65: Ngôn ngữ theo dự án

• Mục tiêu: Đọc đa ngôn ngữ.

• Lý thuyết: C (kernel), Go (k8s), Rust (TiKV), C++ (ClickHouse).

• Thực hành: So phong cách codebase.

Ngày 66: Đọc C++ lớn

• Mục tiêu: Vào codebase C++.

• Lý thuyết: template, namespace, build phức tạp.

• Thực hành: Navigate một C++ codebase.

Ngày 67: Đọc Go lớn

• Mục tiêu: Vào codebase Go.

• Lý thuyết: interface, package, generate.

• Thực hành: Navigate một Go codebase.

Ngày 68: Đọc Rust lớn

• Mục tiêu: Vào codebase Rust.

• Lý thuyết: trait, module, ownership khi đọc.

• Thực hành: Navigate một Rust codebase.

Ngày 69: Testing approach của dự án

• Mục tiêu: Hiểu cách họ test.

• Lý thuyết: unit/integration/e2e, fixture.

• Thực hành: Đọc test infra một dự án.

Ngày 70: CI/CD của dự án

• Mục tiêu: Biết CI trước khi PR.

• Lý thuyết: CI pipeline, required checks.

• Thực hành: Đọc CI config; chạy check local.

Ngày 71: Tìm cơ hội đóng góp

• Mục tiêu: Chuẩn bị PR.

• Lý thuyết: bug/docs/test/feature; issue tracker.

• Thực hách: Lập danh sách issue tiềm năng (3 domain).

Ngày 72: Ôn Khối B

• Mục tiêu: Chốt reading portfolio.

• Lý thuyết: rà các subsystem đã đọc.

• Thực hành: Chuẩn bị đóng góp.

KHỐI C - Contribution Mechanics (Ngày 73-90) → P3

Ngày 73: OSS contribution - tổng quan

• Mục tiêu: Cách đóng góp.

• Lý thuyết: types: docs/test/bugfix/feature/refactor.

• Thực hành: Chọn loại đóng góp đầu tiên (nên nhỏ).

Ngày 74: Tìm issue

• Mục tiêu: Chọn việc vừa sức.

• Lý thuyết: good-first-issue, help-wanted, triage.

• Thực hành: Chọn 1 issue domain 1.

Ngày 75: CONTRIBUTING.md

• Mục tiêu: Theo luật chơi.

• Lý thuyết: đọc contribution guide.

• Thực hành: Đọc + tuân guide dự án.

Ngày 76: DCO vs CLA

• Mục tiêu: Ký đúng.

• Lý thuyết: DCO (Signed-off-by) vs CLA.

• Thực hành: Ký commit đúng chuẩn dự án.

Ngày 77: Code of conduct

• Mục tiêu: Cộng đồng lành mạnh.

• Lý thuyết: CoC, chuẩn giao tiếp.

• Thực hành: Đọc CoC; chuẩn bị tương tác.

Ngày 78: Git workflow

• Mục tiêu: Đóng góp gọn gàng.

• Lý thuyết: fork, branch, commit hygiene, rebase.

• Thực hành: Setup fork + branch.

Ngày 79: Commit & PR nhỏ

• Mục tiêu: Dễ review.

• Lý thuyết: conventional commit, small focused PR.

• Thực hành: Chuẩn commit message.

Ngày 80: Build & test local

• Mục tiêu: Chắc chắn trước khi gửi.

• Lý thuyết: build + run test suite (nối Khối B).

• Thực hành: Chạy full test local.

Ngày 81: Lint & style

• Mục tiêu: Qua CI style.

• Lý thuyết: linter, formatter, style guide.

• Thực hành: Chạy lint; sửa style.

Ngày 82: Viết issue tốt

• Mục tiêu: Báo cáo rõ ràng.

• Lý thuyết: reproduction, expected vs actual.

• Thực hành: Viết một issue chất lượng (nếu cần).

Ngày 83: Mở PR

• Mục tiêu: PR chuyên nghiệp.

• Lý thuyết: description, link issue, checklist.

• Thực hành: Draft PR description.

Ngày 84: PR nhỏ & tập trung

• Mục tiêu: Tăng khả năng merge.

• Lý thuyết: một PR một mục tiêu.

• Thực hành: Rà PR đủ nhỏ.

Ngày 85: Nhận review

• Mục tiêu: Đón feedback đúng cách.

• Lý thuyết: không phòng thủ, hỏi rõ.

• Thực hành: Phản hồi review lịch sự.

Ngày 86: Iterate review

• Mục tiêu: Sửa theo góp ý.

• Lý thuyết: address comment, force-push vs new commit.

• Thực hành: Cập nhật PR theo review.

Ngày 87: CI & checks

• Mục tiêu: Xanh mọi check.

• Lý thuyết: required checks, flaky test.

• Thực hành: Làm CI pass.

Ngày 88: Giao tiếp maintainer

• Mục tiêu: Kiên nhẫn & tôn trọng.

• Lý thuyết: thời gian review, ping lịch sự, tôn trọng thời gian họ.

• Thực hành: Soạn tin nhắn follow-up đúng mực.

Ngày 89: Linux vs GitHub process

• Mục tiêu: Biết khác biệt quy trình.

• Lý thuyết: mailing-list patch (kernel) vs PR (GitHub).

• Thực hành: Chuẩn bị patch/PR đúng quy trình dự án.

Ngày 90: CỘT MỐC 90

• Mục tiêu: Chốt cơ chế; gửi PR đầu tiên.

• Lý thuyết: Ôn C; kiểm kê: workflow contribution + PR #1 (domain 1) đã mở.

• Thực hành: P3 done (PR #1 domain 1 đã gửi + đang review); đề thi #3 (contribution workflow) + tự chấm; blog #125 ("PR đầu tiên vào một dự án OSS lớn: từ good-first-issue tới review"); tag layer13-day090; nghỉ nửa ngày. Đã đi 90/120 (75%).

KHỐI D - Making Contributions (Ngày 91-114) → P4 (3 PR xuyên domain)

Ngày 91: PR #1 - tới merge

• Mục tiêu: Landing PR đầu (domain 1).

• Lý thuyết: iterate review → approve → merge.

• Thực hành: Đưa PR #1 tới merge.

Ngày 92: Xử lý feedback/rework

• Mục tiêu: Bền bỉ qua review.

• Lý thuyết: rework lớn, giữ scope.

• Thực hành: Xử một vòng feedback khó.

Ngày 93: Bug fix lớn hơn

• Mục tiêu: Đóng góp có giá trị.

• Lý thuyết: reproduce → RCA (nối Layer 11) → fix.

• Thực hành: Tìm + fix một bug thật.

Ngày 94: Viết test cho fix

• Mục tiêu: Fix có test.

• Lý thuyết: regression test.

• Thực hành: Thêm test cho bug fix.

Ngày 95: PR #2 - chọn domain 2

• Mục tiêu: Domain khác.

• Lý thuyết: chọn dự án + issue domain 2.

• Thực hành: Chọn issue; hiểu code liên quan.

Ngày 96: PR #2 - implement

• Mục tiêu: Sửa/thêm.

• Lý thuyết: thay đổi tối thiểu, đúng.

• Thực hành: Cài đặt fix.

Ngày 97: PR #2 - test + docs

• Mục tiêu: Đầy đủ.

• Lý thuyết: test + cập nhật docs.

• Thực hành: Thêm test + docs.

Ngày 98: PR #2 - gửi + review

• Mục tiêu: Mở PR.

• Lý thuyết: description, CI.

• Thực hành: Gửi PR #2.

Ngày 99: PR #2 - iterate

• Mục tiêu: Qua review.

• Lý thuyết: address feedback.

• Thực hành: Cập nhật theo review.

Ngày 100:

• Mục tiêu: Kiểm kê lớn giữa Layer 13.

• Lý thuyết: Ôn A→C + đầu D; kiểm kê lớn: đọc nhiều codebase + PR #1 merged + PR #2 đang review; đối chiếu đích "đóng góp OSS".

• Thực hành: Đề thi #4 tích lũy (đọc + contribution) + tự chấm theo rubric; blog #126 ("Từ đọc source tới PR merged: hành trình vào một cộng đồng OSS"); tag layer13-day100; nghỉ nửa ngày. Đã đi 100/120 (83%).

Ngày 101: PR #3 - chọn domain 3

• Mục tiêu: Domain thứ ba.

• Lý thuyết: chọn dự án + issue domain 3.

• Thực hành: Chọn issue; hiểu code.

Ngày 102: PR #3 - implement

• Mục tiêu: Sửa/thêm.

• Lý thuyết: thay đổi đúng, gọn.

• Thực hành: Cài đặt.

Ngày 103: PR #3 - test + docs

• Mục tiêu: Đầy đủ.

• Lý thuyết: test + docs.

• Thực hành: Thêm test + docs.

Ngày 104: PR #3 - gửi + review

• Mục tiêu: Mở PR.

• Lý thuyết: description, CI.

• Thực hành: Gửi PR #3.

Ngày 105: PR #3 - iterate

• Mục tiêu: Qua review.

• Lý thuyết: address feedback.

• Thực hành: Cập nhật theo review.

Ngày 106: Feature contribution

• Mục tiêu: Đóng góp lớn hơn.

• Lý thuyết: propose qua issue/RFC trước khi code.

• Thực hành: Draft một proposal.

Ngày 107: Design với maintainer

• Mục tiêu: Đồng thuận thiết kế.

• Lý thuyết: thảo luận design, chấp nhận thay đổi hướng.

• Thực hành: Kịch bản thảo luận design.

Ngày 108: Xử lý bị từ chối

• Mục tiêu: Đón nhận nhã nhặn.

• Lý thuyết: PR bị close/redirect, học từ đó.

• Thực hành: Rút bài học từ một rejection.

Ngày 109: Backport & release

• Mục tiêu: Hiểu vòng đời release.

• Lý thuyết: backport, release branch, changelog.

• Thực hành: Đọc release process một dự án.

Ngày 110: Follow-up sau merge

• Mục tiêu: Trách nhiệm sau merge.

• Lý thuyết: theo dõi regression, sửa nhanh.

• Thực hành: Kế hoạch follow-up.

Ngày 111: Documenting contributions

• Mục tiêu: Ghi lại đóng góp.

• Lý thuyết: portfolio: PR link + mô tả tác động.

• Thực hành: Bắt đầu contribution portfolio.

Ngày 112: P4 - shepherd 3 PR tới merge

• Mục tiêu: Đưa cả 3 tới đích.

• Lý thuyết: kiên nhẫn qua review nhiều vòng.

• Thực hành: Theo sát 3 PR (domain 1/2/3).

Ngày 113: P4 - writeup đóng góp

• Mục tiêu: Ghi lại hành trình.

• Lý thuyết: mỗi PR: vấn đề → fix → review → merge.

• Thực hành: Writeup 3 đóng góp.

Ngày 114: P4 - 3 PR xuyên domain

• Mục tiêu: Release P4.

• Lý thuyết: rà "done": 3 PR ở 3 domain khác nhau (merged/in-review).

• Thực hành: Đóng gói + blog #127 ("Ba PR ở ba domain khác nhau: container, observability, data"). P4 done.

KHỐI E - Sustained Contribution (Ngày 115-120) → P5 flagship

Ngày 115: Sustained contributor

• Mục tiêu: Từ one-off tới đều đặn.

• Lý thuyết: đóng góp liên tục, xây uy tín.

• Thực hành: Chọn một dự án để theo sâu.

Ngày 116: Review PR người khác

• Mục tiêu: Đóng góp bằng review.

• Lý thuyết: review có tính xây dựng (nối Leadership).

• Thực hành: Review một PR của người khác.

Ngày 117: Path to maintainer

• Mục tiêu: Lộ trình committer/maintainer.

• Lý thuyết: reviewer → committer → maintainer, cách được đề cử.

• Thực hành: Kế hoạch tiến tới committer.

Ngày 118: RFC & design leadership

• Mục tiêu: Dẫn dắt kỹ thuật (nối Leadership).

• Lý thuyết: author một RFC/KEP, dẫn dắt thảo luận.

• Thực hành: Draft một RFC cho một dự án.

Ngày 119: P5 - portfolio + lộ trình; ôn Layer 13

• Mục tiêu: Chốt flagship.

• Lý thuyết: 3 merged PR + review + lộ trình sustained.

• Thực hành: Portfolio hoàn chỉnh + plan; rà toàn layer.

Ngày 120: HOÀN THÀNH LAYER 13

• Mục tiêu: Chốt Source Code Reading & Contribution - đạt đích cuối của chương trình.

• Lý thuyết: Ôn toàn layer; kiểm kê tổng: P1 đọc 2 codebase + P2 subsystem architecture doc + P3 PR #1 + P4 3 PR xuyên domain + P5 portfolio + lộ trình sustained contributor.

• Thực hành: P5 done (≥1 merged PR ở 3 dự án khác domain); đề thi #5 tích lũy (đọc + đóng góp) + tự chấm theo rubric; blog #128 ("Nhìn lại Source Code Reading & Contribution: đọc được và đóng góp được cho OSS lớn"); tag layer13-complete; nghỉ nửa ngày.