Computer Systems: A Programmer's Perspective Bản đồ toàn cuốn · Whole-book map

Bản đồ toàn cuốn · 12 chương · 4 mạch Whole-book map · 12 chapters · 4 movements

Mười hai chương, một hành trình duy nhất của một chương trình Cả cuốn sách đi theo một chương trình, từ đầu tới cuối Twelve chapters, one single journey of one program

Đọc tuần tự, Computer Systems: A Programmer's Perspective trông như mười hai chủ đề rời nhau: bit, hợp ngữ, bộ xử lý, tối ưu, cache, liên kết, ngoại lệ, bộ nhớ ảo, vào/ra, mạng, đồng thời. Đọc như một lập luận thì nó là một hành trình duy nhất: cùng một chương trình đi từ dòng mã C bạn viết, xuống phần cứng, rồi được hệ điều hành nâng đỡ để chạy và giao tiếp với thế giới.1 Trang này bày cả mười hai chương ra cùng lúc để nhìn thấy hành trình đó — và gọi tên những sợi chỉ chạy xuyên nhiều chương mà lối đọc tuần tự dễ bỏ sót.

Cuốn sách có mười hai chương, nghe thì nhiều. Nhưng chúng kể cùng một câu chuyện: một chương trình nhỏ của bạn được máy biến thành số, chạy trên phần cứng, rồi được hệ điều hành chăm cho tới lúc nói chuyện với máy khác. Trang này vẽ cả câu chuyện ra một lần. Nhớ nhé: nhìn cả con đường trước, rồi hãy bước vào từng chặng.

Read sequentially, Computer Systems: A Programmer's Perspective looks like twelve separate subjects: bits, assembly, the processor, optimization, caches, linking, exceptions, virtual memory, I/O, networks, concurrency. Read as an argument, it is one single journey: the same program travels from the C you write, down to the hardware, then up through the operating system that lets it run and talk to the world.1 This page lays all twelve chapters out at once so that journey becomes visible — and names the threads running across chapters that sequential reading tends to miss.

Lập luận này không phải suy diễn của trang này: các tác giả nói thẳng mục đích của cả cuốn sách ngay ở Chương 1 — giúp bạn trở thành lập trình viên giỏi hơn bằng cách hiểu hệ thống nằm dưới ngôn ngữ bậc cao.1 Trang chủ của sách tại Carnegie Mellon cũng mô tả cùng một ý: cách tiếp cận này nhằm giúp người học “trở thành lập trình viên giỏi hơn và chuẩn bị cho các môn hệ thống nâng cao”.2 Mười một chương còn lại là mười một lần đi sâu vào một chặng của cùng hành trình mà Chương 1 đã phác ra.

Luận đề của bản đồ: mọi chương của cuốn sách hoặc (a) mở một tầng trừu tượng giữa mã nguồn và phần cứng, hoặc (b) chỉ cho bạn hệ điều hành dựng môi trường chạy cho chương trình, hoặc (c) cho chương trình bước ra ngoài một máy đơn lẻ. Biết một chương thuộc loại nào là đã biết phải đọc nó thế nào.

Ý chính: mỗi chương làm một trong ba việc — mở một lớp bên dưới mã của bạn, cho thấy hệ điều hành đỡ chương trình ra sao, hoặc cho chương trình nói chuyện với bên ngoài. Nhớ nhé: ba kiểu chương, thế thôi.

The map's thesis: every chapter either (a) opens a layer of abstraction between source code and hardware, (b) shows the operating system building the runtime environment for a program, or (c) lets the program step beyond a single machine. Knowing which kind a chapter is tells you how to read it.

Lập luận · 00 The argument · 00

Cuốn sách không dạy mười hai chủ đề — nó dạy một cách nhìn, mười hai lần Một cách nhìn duy nhất, được dùng đi dùng lại The book does not teach twelve subjects — it teaches one way of looking, twelve times

Bryant và O'Hallaron mở sách bằng một mục đích rõ ràng: họ viết cho lập trình viên muốn hiểu điều gì xảy ra bên dưới ngôn ngữ bậc cao, để viết mã nhanh hơn, đúng hơn và an toàn hơn.1 Từ đó, cả cuốn sách cắt khoảng cách giữa mã nguồn và phần cứng thành một chồng tầng trừu tượng — và mỗi chương mở ra đúng một tầng.1 Trang chủ của sách tại Carnegie Mellon xác nhận cùng tinh thần đó: giúp người học “trở thành lập trình viên giỏi hơn”.2

Các tác giả bắt đầu bằng một lời hứa: nếu bạn hiểu máy chạy chương trình thế nào, bạn sẽ viết mã tốt hơn. Rồi họ chia khoảng cách giữa “mã bạn viết” và “cái máy thật” thành nhiều tầng, mỗi chương mở một tầng. Nhớ nhé: cả cuốn sách chỉ là mở từng tầng một, từ trên xuống dưới rồi lại lên.

Bryant and O'Hallaron open the book with a clear purpose: they write for programmers who want to understand what happens underneath a high-level language, so they can write code that is faster, more correct and more secure.1 From there, the whole book cuts the gap between source code and hardware into a stack of abstraction layers — and each chapter opens exactly one layer.1 The book's home page at Carnegie Mellon confirms the same spirit: to help learners "become better programmers."2

Ba kiểu chương. (a) Mở một tầng trừu tượng — Chương 2, 3, 4, 6, 9 trình bày một lớp giữa mã C và mạch điện và gọi tên từng phần. (b) Dựng môi trường chạy — Chương 7, 8, 10 cho thấy hệ điều hành ghép, nạp, điều phối và kết nối chương trình với thế giới. (c) Tận dụng hoặc mở rộng hệ thống — Chương 5 khai thác hiểu biết đó để tăng tốc; Chương 11 và 12 đưa chương trình ra ngoài một máy.

Nói đơn giản. Có chương vẽ một lớp bên trong máy, có chương kể hệ điều hành đỡ chương trình ra sao, có chương dạy dùng hiểu biết đó để chạy nhanh hơn hay nói chuyện với máy khác. Nhớ nhé: biết chương thuộc loại nào thì biết nên đọc nhanh hay đọc chậm.

Three kinds of chapter. (a) Opening an abstraction layer — Chapters 2, 3, 4, 6 and 9 lay out one layer between C and the circuits and name each part. (b) Building the runtime environment — Chapters 7, 8 and 10 show the operating system linking, loading, scheduling and connecting a program to the world. (c) Exploiting or extending the system — Chapter 5 uses that understanding to go faster; Chapters 11 and 12 take the program beyond one machine.

mã C → biên dịch → lệnh máy → bộ xử lý + phân cấp bộ nhớ → hệ điều hành (tiến trình · bộ nhớ ảo · tệp) → mạng

mã của bạn → dịch sang số → chạy trên phần cứng → hệ điều hành đỡ → nói chuyện với máy khác

C source → compilation → machine code → processor + memory hierarchy → operating system (processes · virtual memory · files) → network

Chương 1 không chỉ phác hành trình: Mục 1.9 còn liệt kê tường minh những trừu tượng quan trọng nhất mà hệ thống cung cấp — kiến trúc tập lệnh (instruction set architecture), tệp, bộ nhớ ảo, tiến trình, và máy ảo.1 Mỗi trừu tượng đó chính là một chương sau này: chúng không rải rác ngẫu nhiên mà là một danh mục có chủ ý.

Cách dùng trang này. Bốn mạch bên dưới bám theo cấu trúc ba phần của chính cuốn sách, nhưng đọc nó như một lập luận: mỗi mạch nói rõ nó thêm gì vào cái trước. Mỗi thẻ chương mở thẳng vào trang đồng hành của chương đó. Nếu bạn đang truy một khái niệm cụ thể, mục Sợi chỉ xuyên suốt chỉ ra nó xuất hiện ở những chương nào — vì hầu hết ý tưởng lớn của cuốn sách xuất hiện nhiều hơn một lần.

Bấm vào tên chương là mở cả chương. Nếu bạn muốn tìm một ý, kéo xuống mục “Sợi chỉ xuyên suốt” — ở đó ghi ý đó nằm ở những chương nào. Nhớ nhé: không bắt buộc phải đọc theo thứ tự 1, 2, 3.

How to use this page. The four movements below follow the book's own three-part structure, but read it as an argument: each says what it adds to the one before. Every chapter card opens that chapter's companion page directly. If you are hunting a specific idea, the through-lines section names every chapter it appears in — because most of the book's big ideas appear more than once.

Mở đầu · Chương 1 Opening · Chapter 1

Một chương trình bé xíu dẫn bạn đi khắp cả hệ thống Chương đầu là tấm bản đồ trước khi vào từng con đường One tiny program walks you through the whole system

Chương mở đầu phác ra toàn bộ bản đồ. Các tác giả dõi theo vòng đời của một chương trình hello duy nhất — từ lúc được gõ ra, qua bốn pha biên dịch, nạp vào bộ nhớ, chạy trên bộ xử lý, cho tới khi in dòng chữ của nó — và mỗi khi chương trình bước sang một giai đoạn mới, một khái niệm lớn được giới thiệu đúng lúc.1 Nhờ vậy mọi chủ đề của mười một chương sau đều xuất hiện ở đây lần đầu, dưới dạng gọn nhất.

Chương đầu dắt bạn đi một vòng nhanh: một chương trình nhỏ xíu tên hello chạy như thế nào, và trên đường đi nó gặp những “nhân vật” nào — trình biên dịch, bộ nhớ đệm, hệ điều hành, mạng. Nhớ nhé: đây là tấm bản đồ, các chương sau là từng con đường.

The opening chapter sketches the whole map. The authors trace the lifetime of a single hello program — from being typed, through four compilation phases, loaded into memory, run on the processor, until it prints its line — and each time the program enters a new stage, a big concept is introduced right when it is needed.1 Every subject of the next eleven chapters first appears here in its most compact form.

Điều mạch này thêm vào: một bản đồ. Sau Chương 1, mọi câu hỏi về hệ thống đều có thể hỏi lại thành “chặng này của hành trình nằm ở chương nào?” Chương 1 cũng khép lại bằng Mục 1.9, nơi các tác giả liệt kê các chủ đề xuyên suốt — một mục lục ngầm cho cả cuốn sách.1

Nói đơn giản. Bạn có một tấm bản đồ: thứ này xảy ra ở chặng nào trên đường đi của chương trình? Nhớ nhé: hỏi đúng chặng là tìm đúng chương.

What this movement adds: a map. After Chapter 1, every system question can be restated as "which chapter does this stage of the journey live in?" Chapter 1 also closes with Section 1.9, where the authors list the cross-cutting themes — an implicit table of contents for the whole book.1

hello.c → cpp → cc1 → as → ld → hello → nạp vào bộ nhớ → bộ xử lý thực thi → in ra màn hình

văn bản → bốn bước dịch → tệp chạy được → nạp vào máy → chạy → in dòng chữ

hello.c → cpp → cc1 → as → ld → hello → loaded into memory → processor executes → prints to screen

  1. Chapter 1

    Dạo quanh hệ thống: cả cuốn sách trong một chương Một vòng nhanh qua cả cái máy A tour of the system: the whole book in one chapter

    Thông tin là bit cộng ngữ cảnh; chương trình được dịch qua bốn pha; phần cứng gồm bus, bộ xử lý và bộ nhớ chính; cache và phân cấp bộ nhớ L0–L6 chi phối hiệu năng; hệ điều hành cung cấp tiến trình, bộ nhớ ảo và tệp; mạng chỉ là một thiết bị vào/ra nữa.1 Tất cả gói trong một chương.

    Chương 1 chạm vào mọi ý lớn: mọi thứ là số 0 và 1; máy phải dịch chương trình; bộ nhớ xếp thành nhiều tầng nhanh–chậm; hệ điều hành chia sẻ máy; mạng chỉ là một thiết bị. Nhớ nhé: đọc chương này là có ngay cái khung để treo mọi chương sau vào.

    Information is bits plus context; a program is translated in four phases; hardware is buses, the processor and main memory; caches and the L0–L6 memory hierarchy govern performance; the operating system provides processes, virtual memory and files; the network is just another I/O device.1 All in one chapter.

    Điểm nốiWhere it connects Mỗi đoạn của Chương 1 là một chương sau được nén lại: bit → Ch 2, lệnh máy → Ch 3–4, cache → Ch 5–6, tiến trình và bộ nhớ ảo → Ch 8–9, mạng → Ch 11.1 Each passage of Chapter 1 is a later chapter compressed: bits → Ch 2, machine code → Ch 3–4, caches → Ch 5–6, processes and virtual memory → Ch 8–9, networking → Ch 11.1

Phần I · Chương 2–6 Part I · Chapters 2–6

Cấu trúc và thực thi: mở hộp đen giữa mã nguồn và phần cứng Bên dưới một dòng lệnh, máy thật sự làm gì Structure and execution: opening the black box between code and hardware

Năm chương này là trái tim của cuốn sách. Chúng theo một trật tự xuống rồi lại lên: dữ liệu được biểu diễn bằng bit ra sao (Ch 2), chương trình trông thế nào ở mức máy (Ch 3), bộ xử lý thực thi lệnh thế nào (Ch 4), làm sao viết mã chạy nhanh hơn (Ch 5), và vì sao phân cấp bộ nhớ chi phối hiệu năng (Ch 6).1 Đây là phần mà hiểu biết đổi thẳng thành mã tốt hơn.

Phần này trả lời câu hỏi: bên dưới một dòng lệnh, máy làm gì với các con số và với bộ nhớ? Nó đi từ cách lưu số, tới lệnh máy, tới bộ xử lý, tới mẹo chạy nhanh, tới bộ nhớ nhiều tầng. Nhớ nhé: đây là phần cốt lõi để viết mã nhanh và đúng.

These five chapters are the heart of the book. They follow a down-then-up order: how data is represented in bits (Ch 2), what a program looks like at the machine level (Ch 3), how the processor executes instructions (Ch 4), how to make code run faster (Ch 5), and why the memory hierarchy governs performance (Ch 6).1 This is where understanding converts directly into better code.

Điều mạch này thêm vào: chiều sâu. Chương 1 cho cái nhìn một tầng; ở đây mỗi tầng được mở ra tới tận cơ chế — biểu diễn số hữu hạn, mã x86-64, đường ống bộ xử lý, song song mức lệnh, và vì sao tính cục bộ (locality) khiến cache hoạt động.1

Nói đơn giản. Phần này mở từng cái hộp Chương 1 đã chỉ, nhìn vào tận bên trong. Nhớ nhé: biết bên trong thì mới biết vì sao mã chạy nhanh hay chậm.

What this movement adds: depth. Chapter 1 gave a one-level view; here each level is opened down to its mechanism — finite number representation, x86-64 code, the processor pipeline, instruction-level parallelism, and why locality makes caches work.1

bit → số nguyên & dấu phẩy động (Ch 2) → hợp ngữ x86-64 (Ch 3) → vi kiến trúc bộ xử lý (Ch 4)

số → lệnh máy → bộ xử lý → mẹo chạy nhanh → bộ nhớ nhiều tầng

bits → integers & floating point (Ch 2) → x86-64 assembly (Ch 3) → processor microarchitecture (Ch 4)

tối ưu + song song mức lệnh (Ch 5) + tính cục bộ & cache (Ch 6) → hiệu năng thật

optimization + instruction-level parallelism (Ch 5) + locality & caches (Ch 6) → real performance

  1. Chapter 2

    Biểu diễn thông tin: số trên máy không phải số trong toán Số trong máy khác số bạn học ở trường Representing information: machine numbers are not math numbers

    Chương này trình bày ba cách mã hoá: số nguyên không dấu, số nguyên bù hai, và số dấu phẩy động theo chuẩn IEEE.1 Thông điệp trung tâm là biểu diễn máy hữu hạn, nên phép cộng có thể tràn và số thực chỉ là xấp xỉ — nguồn gốc của nhiều lỗi số học và lỗ hổng bảo mật.1

    Máy lưu số trong một số bit cố định, nên số quá lớn sẽ “tràn”, và số lẻ chỉ gần đúng. Đó là lý do đôi khi phép tính cho kết quả lạ. Nhớ nhé: số trong máy có giới hạn, không vô hạn như trong toán.

    The chapter lays out three encodings: unsigned integers, two's-complement integers, and IEEE floating point.1 Its central message is that machine representation is finite, so addition can overflow and reals are only approximations — the source of many arithmetic bugs and security holes.1

    Điểm nốiWhere it connects Đây là tầng dưới cùng của mọi chương sau: mọi lệnh máy ở Chương 3 đều thao tác trên các bit được mã hoá đúng như ở đây. This is the bottom layer of every later chapter: every machine instruction in Chapter 3 operates on bits encoded exactly as here.

  2. Chapter 3

    Mức máy: mã C của bạn thật ra là x86-64 Chương trình của bạn trông thế nào ở dạng lệnh máy Machine level: your C is really x86-64

    Chương dài nhất và trung tâm nhất: nó dạy đọc hợp ngữ x86-64 mà trình biên dịch sinh ra — thanh ghi, truy cập bộ nhớ, rẽ nhánh, vòng lặp, lời gọi thủ tục và ngăn xếp.1 Chương cũng dành hẳn một phần cho tràn bộ đệm (buffer overflow), cho thấy hiểu mức máy là hiểu cả một lớp lỗ hổng bảo mật.1

    Chương này cho bạn thấy dòng mã C của mình biến thành những lệnh máy nào. Nhờ đó bạn hiểu vì sao chương trình chạy thế này mà không thế kia, và vì sao kẻ xấu có thể lợi dụng lỗi tràn bộ đệm. Nhớ nhé: đọc được hợp ngữ là nhìn thấy sự thật của chương trình.

    The longest and most central chapter: it teaches you to read the x86-64 assembly the compiler emits — registers, memory access, branches, loops, procedure calls and the stack.1 It devotes a whole section to buffer overflow, showing that understanding the machine level means understanding a whole class of security holes.1

    Điểm nốiWhere it connects Ngăn xếp lời gọi thủ tục học ở đây quay lại thành khung ngăn xếp ở Chương 8 và vùng nhớ của tiến trình ở Chương 9.1 The procedure call stack learned here returns as stack frames in Chapter 8 and the process address space in Chapter 9.1

  3. Chapter 4

    Kiến trúc bộ xử lý: dựng một CPU từ lệnh lên Bộ xử lý chạy lệnh ra sao, nhìn từ bên trong Processor architecture: building a CPU from the instructions up

    Các tác giả định nghĩa một tập lệnh nhỏ tên Y86-64, rồi dựng hai hiện thực: một bộ xử lý tuần tự đơn giản, rồi một bộ xử lý đường ống (pipelined) nhanh hơn nhiều.1 Qua đó bạn thấy vì sao lệnh máy có hình dạng như vậy, và hiểu nền tảng cho song song mức lệnh mà Chương 5 khai thác.1

    Chương này dạy bạn tự dựng một bộ xử lý tí hon bằng logic, để thấy “bên trong CPU” thật ra làm gì khi chạy một lệnh. Nhớ nhé: hiểu bộ xử lý là hiểu vì sao có lệnh chạy nhanh, lệnh chạy chậm.

    The authors define a small instruction set called Y86-64, then build two implementations: a simple sequential processor, then a much faster pipelined one.1 Along the way you see why machine instructions have the shape they do, and grasp the basis for the instruction-level parallelism Chapter 5 exploits.1

    Điểm nốiWhere it connects Đường ống của Chương 4 là lý do kỹ thuật cho mọi mẹo tối ưu ở Chương 5: muốn tăng tốc, phải nuôi đủ lệnh cho đường ống. Chapter 4's pipeline is the technical reason behind every optimization trick in Chapter 5: to go faster, you must keep the pipeline fed.

  4. Chapter 5

    Tối ưu hiệu năng: nhanh hơn độ phức tạp tiệm cận Làm sao cho cùng một thuật toán chạy nhanh hơn Optimizing performance: beyond asymptotic complexity

    Chương này dạy viết mã mà cả trình biên dịch lẫn bộ xử lý đều xử lý hiệu quả: loại bỏ chướng ngại tối ưu, khai thác song song mức lệnh, và đo bằng đơn vị chu kỳ trên mỗi phần tử (CPE).1 Thông điệp: hiệu năng không chỉ là độ phức tạp tiệm cận — cùng một thuật toán có thể nhanh chậm khác nhau nhiều lần.1

    Hai cách viết cùng một thuật toán có thể chênh nhau nhiều lần về tốc độ. Chương này chỉ cách viết sao cho máy chạy mượt nhất. Nhớ nhé: nhanh hay chậm không chỉ do thuật toán, còn do cách viết.

    This chapter teaches you to write code that both the compiler and the processor handle efficiently: removing optimization blockers, exploiting instruction-level parallelism, and measuring in cycles per element (CPE).1 The message: performance is not only asymptotic complexity — the same algorithm can run several times faster or slower.1

    Điểm nốiWhere it connects Chương 5 là chương “thu hoạch” của Phần I: nó dùng hợp ngữ (Ch 3), đường ống (Ch 4) và cache (Ch 6) cùng một lúc. Chapter 5 is Part I's harvest chapter: it uses assembly (Ch 3), the pipeline (Ch 4) and caches (Ch 6) all at once.

  5. Chapter 6

    Phân cấp bộ nhớ: vì sao tính cục bộ quyết định tốc độ Bộ nhớ xếp thành nhiều tầng, và vì sao điều đó quan trọng The memory hierarchy: why locality decides speed

    Chương trình bày công nghệ lưu trữ (SRAM, DRAM, đĩa), rồi khái niệm tính cục bộ (locality) — xu hướng chương trình truy cập lại dữ liệu gần nhau về thời gian và không gian — và cách cache khai thác nó.1 Kết thúc bằng cách viết mã thân thiện với cache, một kỹ năng đổi thẳng thành tốc độ.1

    Bộ nhớ nhanh thì đắt và nhỏ, bộ nhớ rẻ thì chậm và to, nên máy xếp chúng thành nhiều tầng. Chương trình chạy nhanh khi dùng lại dữ liệu gần nhau. Nhớ nhé: truy cập dữ liệu “gần nhau” thì máy chạy nhanh hơn nhiều.

    The chapter presents storage technologies (SRAM, DRAM, disk), then the idea of locality — a program's tendency to reuse data near one another in time and space — and how caches exploit it.1 It ends with writing cache-friendly code, a skill that converts straight into speed.1

    Điểm nốiWhere it connects Phân cấp bộ nhớ ở đây là nền cho bộ nhớ ảo ở Chương 9: cả hai đều là cùng một ý — dùng tầng nhanh làm bộ đệm cho tầng chậm.1 The memory hierarchy here is the foundation for virtual memory in Chapter 9: both are the same idea — a fast level caching a slow one.1

Phần II · Chương 7–10 Part II · Chapters 7–10

Chạy trên hệ thống: hệ điều hành dựng môi trường cho chương trình Chương trình không bao giờ chạy một mình Running on a system: the OS builds the environment for the program

Bốn chương này chuyển trọng tâm từ chương trình sang hệ thống chạy nó. Hệ điều hành ghép nhiều mô-đun thành một tệp chạy (Ch 7), xử lý ngoại lệ và chuyển đổi tiến trình (Ch 8), ảo hoá bộ nhớ cho mỗi tiến trình (Ch 9), và trao đổi dữ liệu với thế giới qua vào/ra mức hệ thống (Ch 10).1 Đây là nơi những trừu tượng mà Chương 1 hứa hẹn — tiến trình, bộ nhớ ảo, tệp — được dựng thật.1

Phần này kể hệ điều hành làm “sân khấu” cho chương trình diễn: ghép các mảnh mã lại, chia lượt chạy, chia bộ nhớ, và cho phép đọc ghi tệp. Nhớ nhé: chương trình luôn chạy trong một hệ thống, không phải khoảng không.

These four chapters shift focus from the program to the system that runs it. The operating system links many modules into one executable (Ch 7), handles exceptions and switches processes (Ch 8), virtualizes memory for each process (Ch 9), and exchanges data with the world through system-level I/O (Ch 10).1 This is where the abstractions Chapter 1 promised — processes, virtual memory, files — are actually built.1

Điều mạch này thêm vào: môi trường. Phần I coi chương trình như vật thể đứng yên để mổ xẻ; Phần II cho nó sống trong một hệ thống có nhiều tiến trình tranh nhau, có ngoại lệ, có bộ nhớ ảo che giấu bộ nhớ vật lý, và có cả một thế giới tệp và thiết bị bên ngoài.1

Nói đơn giản. Phần I nhìn chương trình nằm yên; Phần II cho nó chạy thật giữa nhiều chương trình khác. Nhớ nhé: sống thật thì phải chia sẻ máy với kẻ khác.

What this movement adds: an environment. Part I treated the program as a still object to dissect; Part II lets it live in a system with many competing processes, exceptions, virtual memory hiding physical memory, and a whole outside world of files and devices.1

nhiều tệp .o → liên kết (Ch 7) → tệp chạy → tiến trình + ngoại lệ (Ch 8)

ghép mã → tệp chạy → tiến trình → bộ nhớ ảo → đọc ghi tệp

many .o files → linking (Ch 7) → executable → processes + exceptions (Ch 8)

bộ nhớ ảo (Ch 9) → vào/ra Unix open·read·write·close (Ch 10) → thế giới bên ngoài

virtual memory (Ch 9) → Unix I/O open·read·write·close (Ch 10) → the outside world

  1. Chapter 7

    Liên kết: ghép nhiều mảnh mã thành một chương trình Nhiều tệp mã được ghép lại thành một thế nào Linking: joining many pieces of code into one program

    Liên kết là quá trình gom nhiều tệp đối tượng thành một tệp chạy được, qua hai việc: phân giải ký hiệu (symbol resolution) và tái định vị (relocation).1 Chương phân biệt liên kết tĩnh với liên kết động và thư viện chia sẻ, và giải thích vì sao hiểu nó giúp gỡ những lỗi “không giải quyết được tham chiếu” khó hiểu.1

    Một chương trình lớn gồm nhiều tệp mã. Trình liên kết ghép chúng lại, nối tên hàm với định nghĩa, và sắp đúng chỗ trong bộ nhớ. Nhớ nhé: lỗi “thiếu định nghĩa” thường là lỗi ở bước ghép này.

    Linking is the process of gathering many object files into one executable, through two jobs: symbol resolution and relocation.1 The chapter distinguishes static linking from dynamic linking and shared libraries, and explains why understanding it fixes baffling "unresolved reference" errors.1

    Điểm nốiWhere it connects Liên kết là pha cuối của hệ thống biên dịch mà Chương 1 phác ra (ld), và thư viện chia sẻ được nạp nhờ cơ chế ánh xạ bộ nhớ của Chương 9.1 Linking is the final phase of the compilation system Chapter 1 sketched (ld), and shared libraries are loaded via the memory-mapping mechanism of Chapter 9.1

  2. Chapter 8

    Luồng điều khiển ngoại lệ: ai cho tiến trình tồn tại Vì sao nhiều chương trình chạy xen kẽ được Exceptional control flow: what lets a process exist

    Dòng điều khiển bình thường chạy tuần tự, nhưng hệ thống còn có những “chỗ gãy” — ngoại lệ, ngắt, tín hiệu, và lời gọi hệ thống — gọi chung là luồng điều khiển ngoại lệ.1 Chính cơ chế này cho phép khái niệm tiến trình tồn tại, và chương dạy fork, exec, wait cùng cách xử lý tín hiệu.1

    Máy phải biết dừng việc đang làm để xử lý việc gấp — bàn phím gõ, đồng hồ điểm, lỗi xảy ra. Nhờ vậy nhiều chương trình mới chạy xen kẽ được như thể mỗi cái có máy riêng. Nhớ nhé: “ngoại lệ” là cách máy chuyển qua lại giữa các việc.

    Normal control flow runs sequentially, but the system also has "breaks" — exceptions, interrupts, signals and system calls — together called exceptional control flow.1 This mechanism is what lets the concept of a process exist, and the chapter teaches fork, exec, wait and signal handling.1

    Điểm nốiWhere it connects Tiến trình dựng ở đây là đơn vị mà Chương 9 cấp cho một không gian nhớ ảo riêng, và là nền cho lập trình đồng thời ở Chương 12.1 The process built here is the unit Chapter 9 gives a private virtual address space, and the basis for concurrent programming in Chapter 12.1

  3. Chapter 9

    Bộ nhớ ảo: mỗi tiến trình tưởng mình có cả bộ nhớ Vì sao mỗi chương trình thấy một bộ nhớ riêng Virtual memory: each process thinks it owns all of memory

    Bộ nhớ ảo là trừu tượng cho mỗi tiến trình một không gian địa chỉ riêng, rộng và liên tục, trong khi bộ nhớ vật lý được chia sẻ và dùng làm bộ đệm cho đĩa.1 Chương dạy dịch địa chỉ, bảng trang (page table), TLB, ánh xạ bộ nhớ, và cả cơ chế cấp phát động như malloc.1

    Nhiều chương trình chạy cùng lúc mà không giẫm lên bộ nhớ của nhau, vì mỗi cái được cho một “bản đồ bộ nhớ” riêng. Hệ điều hành âm thầm dịch địa chỉ giả ấy sang địa chỉ thật. Nhớ nhé: mỗi chương trình tưởng nó có cả bộ nhớ, nhưng thật ra đang chia sẻ.

    Virtual memory is the abstraction giving each process its own large, continuous address space, while physical memory is shared and used as a cache for the disk.1 The chapter teaches address translation, page tables, the TLB, memory mapping, and dynamic allocation such as malloc.1

    Điểm nốiWhere it connects Bộ nhớ ảo là cùng một ý với phân cấp bộ nhớ ở Chương 6 — tầng nhanh làm bộ đệm cho tầng chậm — chỉ áp vào cặp bộ nhớ chính và đĩa.1 Virtual memory is the same idea as the memory hierarchy of Chapter 6 — a fast level caching a slow one — applied to main memory and disk.1

  4. Chapter 10

    Vào/ra mức hệ thống: tệp là giao diện với thế giới Đọc ghi tệp, và vì sao mọi thứ giống một tệp System-level I/O: the file is the interface to the world

    Chương trình bày vào/ra Unix — open, read, write, close — và ý niệm trung tâm rằng nhiều loại thiết bị được trình bày cho ứng dụng dưới dạng tệp.1 Nó cũng nói về mô tả tệp (file descriptor), chia sẻ tệp, siêu dữ liệu, và vì sao các hàm I/O chuẩn được xây trên lớp này.1

    Mở, đọc, ghi, đóng — bốn động tác đó dùng được cho tệp, bàn phím, màn hình, và cả kết nối mạng. Linux làm mọi thứ trông giống một tệp. Nhớ nhé: biết làm việc với tệp là gần như biết nói chuyện với cả thế giới bên ngoài.

    The chapter presents Unix I/O — open, read, write, close — and the central idea that many kinds of device are presented to applications as files.1 It also covers file descriptors, file sharing, metadata, and why the standard I/O functions are built on this layer.1

    Điểm nốiWhere it connects Mô tả tệp học ở đây chính là thứ Chương 11 dùng cho socket mạng: một kết nối mạng cũng mở, đọc, ghi như một tệp.1 The file descriptor learned here is exactly what Chapter 11 uses for network sockets: a network connection is opened, read and written like a file.1

Phần III · Chương 11–12 Part III · Chapters 11–12

Tương tác và giao tiếp: chương trình bước ra ngoài một máy Nói chuyện với máy khác, và làm nhiều việc một lúc Interaction and communication: the program steps beyond one machine

Hai chương cuối là nơi mọi tầng trừu tượng đã học được dùng cùng lúc. Chương 11 cho chương trình nói chuyện với nhau qua mạng theo mô hình máy khách–máy chủ; Chương 12 cho nhiều luồng việc chạy đồng thời trong một chương trình.1 Cả hai đều dựa thẳng lên tiến trình (Ch 8), bộ nhớ ảo (Ch 9) và vào/ra (Ch 10).1

Phần cuối cho chương trình “bước ra khỏi nhà”: gửi dữ liệu qua mạng, và làm nhiều việc một lúc. Đây là lúc mọi thứ học trước đó được ghép lại. Nhớ nhé: hai chương này là bài thi tổng hợp của cả cuốn sách.

The last two chapters are where every abstraction learned so far is used at once. Chapter 11 lets programs talk to each other over the network in a client–server model; Chapter 12 lets several strands of work run concurrently inside one program.1 Both build directly on processes (Ch 8), virtual memory (Ch 9) and I/O (Ch 10).1

Điều mạch này thêm vào: một máy thứ hai và thời gian song song. Chương 11 kéo ranh giới ra ngoài một máy đơn lẻ; Chương 12 cho nhiều dòng điều khiển chạy chồng lên nhau, nơi các lỗi mới — tranh đua (race) và khoá chết (deadlock) — xuất hiện.1

Nói đơn giản. Thêm máy thứ hai, và thêm việc làm cùng lúc. Cả hai đều mạnh nhưng dễ sinh lỗi mới. Nhớ nhé: làm nhiều việc một lúc thì phải cẩn thận hơn.

What this movement adds: a second machine and parallel time. Chapter 11 stretches the boundary beyond one machine; Chapter 12 lets several control flows overlap, where new bugs — races and deadlocks — appear.1

máy khách ↔ socket ↔ máy chủ (Ch 11)  ·  tiến trình · I/O đa kênh · luồng + đồng bộ hoá (Ch 12)

máy này ↔ mạng ↔ máy kia  ·  một chương trình làm nhiều việc một lúc

client ↔ socket ↔ server (Ch 11)  ·  processes · I/O multiplexing · threads + synchronization (Ch 12)

  1. Chapter 11

    Lập trình mạng: máy khách, máy chủ, và socket Hai máy nói chuyện với nhau thế nào Network programming: clients, servers, and sockets

    Chương trình bày mô hình máy khách–máy chủ, giao diện socket, và các khối của một ứng dụng web, rồi dựng một máy chủ web nhỏ hoàn chỉnh làm ví dụ.1 Thông điệp lớn của Chương 1 trả cổ tức ở đây: mạng chỉ là một thiết bị vào/ra, nên lập trình mạng là lập trình vào/ra qua một mô tả tệp đặc biệt.1

    Một bên hỏi (máy khách), một bên trả lời (máy chủ), nối với nhau qua một “ổ cắm” gọi là socket. Chương này còn dựng thử một máy chủ web tí hon. Nhớ nhé: gửi dữ liệu qua mạng cũng là đọc và ghi, như với tệp.

    The chapter presents the client–server model, the socket interface, and the building blocks of a web application, then builds a small complete web server as an example.1 Chapter 1's big message pays off here: the network is just an I/O device, so network programming is I/O programming through a special file descriptor.1

    Điểm nốiWhere it connects Socket dựa thẳng trên vào/ra Unix của Chương 10; một máy chủ thật thường phục vụ nhiều máy khách cùng lúc, dẫn thẳng sang Chương 12. Sockets build directly on the Unix I/O of Chapter 10; a real server usually serves many clients at once, leading straight into Chapter 12.

  2. Chapter 12

    Lập trình đồng thời: ba cách, và những lỗi mới Làm nhiều việc một lúc, và cạm bẫy của nó Concurrent programming: three ways, and new bugs

    Chương trình bày ba cách viết chương trình đồng thời — nhiều tiến trình, vào/ra đa kênh (I/O multiplexing), và luồng (thread) — rồi những vấn đề đi kèm: chia sẻ biến, đồng bộ hoá bằng semaphore, tranh đua và khoá chết.1 Đây là chương khép lại cuốn sách bằng cách dùng gần như mọi thứ đã học.1

    Có ba cách cho máy làm nhiều việc một lúc. Mạnh, nhưng dễ sinh lỗi khi hai việc cùng đụng vào một chỗ. Chương này dạy cách giữ trật tự. Nhớ nhé: làm song song nhanh hơn, nhưng phải khoá cửa cẩn thận.

    The chapter presents three ways to write concurrent programs — multiple processes, I/O multiplexing, and threads — then the problems that come with them: shared variables, synchronization with semaphores, races and deadlocks.1 This chapter closes the book by using nearly everything learned before.1

    Điểm nốiWhere it connects Luồng dùng chung không gian nhớ ảo của Chương 9; đồng thời cũng là một dạng song song, cùng họ với song song mức lệnh và SIMD mà Chương 1 nêu.1 Threads share the virtual address space of Chapter 9; concurrency is also a form of parallelism, of the same family as the instruction-level parallelism and SIMD Chapter 1 named.1

    Ba hình thức song song

    Mục 1.9.1 phân biệt song song mức luồng (thread-level), song song mức lệnh (instruction-level), và song song mức từ dữ liệu kiểu SIMD; Chương 12 chủ yếu khai thác loại thứ nhất.1

    Vì sao song song khó

    Các tác giả nhấn mạnh lập trình đồng thời khét tiếng khó vì lỗi phụ thuộc thời điểm, khó tái hiện — tranh đua và khoá chết là ví dụ điển hình.1

Sợi chỉ xuyên suốt · 6 sợi Through-lines · six threads

Sáu ý quay lại ở nhiều chương, dưới nhiều cái tên Sáu ý lặp đi lặp lại trong cả cuốn sách Six ideas that keep returning, under different names

Đây là phần mà lối đọc tuần tự hay bỏ lỡ. Mỗi sợi dưới đây xuất hiện ở nhiều chương, thường mang tên khác nhau mỗi lần — nên nếu chỉ đọc một chương, bạn thấy một kỹ thuật; đọc cả các chỗ, bạn thấy một nguyên lý. Năm trong sáu sợi được chính các tác giả gọi tên ở Mục 1.9, “Những chủ đề quan trọng”.1

Có sáu ý cứ quay đi quay lại trong sách, mỗi lần đổi tên một chút. Nếu chỉ đọc một chương thì tưởng là mẹo vặt; đọc cả mấy chỗ mới thấy đó là một quy tắc. Nhớ nhé: thấy quen quen thì đúng là bạn đã gặp rồi.

This is the part sequential reading misses. Each thread below appears in several chapters, usually under a different name each time — so one chapter shows you a technique, while all its sites show you a principle. Five of the six are named by the authors themselves in Section 1.9, "Important Themes."1

  1. Thread 01

    Trừu tượng hoá: cùng một mẹo, nhiều cái tên Giấu chi tiết đi để dễ dùng Abstraction: one trick, many names

    Sợi chỉ mà các tác giả tự gọi tên. Mục 1.9 liệt kê các trừu tượng quan trọng nhất của hệ thống: kiến trúc tập lệnh, tệp (trừu tượng của vào/ra), bộ nhớ ảo (trừu tượng của bộ nhớ chính), tiến trình (trừu tượng của một chương trình đang chạy), và máy ảo.1 Mỗi cái là một chương.

    Trừu tượng hoá là mẹo giấu chi tiết rắc rối sau một mặt nạ đơn giản: bạn dùng “tệp”, “tiến trình”, “bộ nhớ” mà không cần biết bên dưới. Nhớ nhé: học một mặt nạ, dùng được cho muôn vàn thứ bên dưới.

    The thread the authors name themselves. Section 1.9 lists the system's most important abstractions: the instruction set architecture, files (the abstraction of I/O), virtual memory (the abstraction of main memory), processes (the abstraction of a running program), and the virtual machine.1 Each is a chapter.

    Xuất hiện ở:Appears in: Ch 1, Ch 4, Ch 9, Ch 10, Ch 8

  2. Thread 02

    Vòng đời chương trình: dịch → liên kết → nạp → chạy Chương trình đi từ chữ tới lúc chạy thế nào The program lifecycle: compile → link → load → run

    Sợi chỉ cấu trúc của cả cuốn sách. Chương 1 phác bốn pha biên dịch của chương trình hello;1 Chương 2 và 3 là nội dung của pha dịch; Chương 7 là pha liên kết; Chương 8 là lúc chương trình được nạp thành một tiến trình và chạy.1 Đi hết sợi này là đi hết một chương trình từ chữ tới lúc sống.

    Từ một tệp chữ tới một chương trình đang chạy phải qua nhiều bước: dọn dẹp, dịch, ghép các mảnh, nạp vào máy, rồi chạy. Mỗi bước là một chương. Nhớ nhé: chương trình có cả một vòng đời, không chỉ lúc chạy.

    The book's structural thread. Chapter 1 sketches the four compilation phases of the hello program;1 Chapters 2 and 3 are the content of the translation phase; Chapter 7 is the linking phase; Chapter 8 is where the program is loaded into a process and run.1 Follow this thread and you follow one program from text to life.

    Xuất hiện ở:Appears in: Ch 1, Ch 3, Ch 7, Ch 8

  3. Thread 03

    Phân cấp bộ nhớ và tính cục bộ Bộ nhớ nhiều tầng, và mẹo “dùng lại cái gần” The memory hierarchy and locality

    Một ý được dùng ba lần ở ba quy mô. Chương 1 giới thiệu cache và phân cấp L0–L6;1 Chương 5 và 6 khai thác tính cục bộ để viết mã nhanh; Chương 9 áp đúng ý đó — tầng nhanh làm bộ đệm cho tầng chậm — vào cặp bộ nhớ chính và đĩa dưới dạng bộ nhớ ảo.1

    Máy xếp bộ nhớ thành nhiều tầng: tầng nhỏ và nhanh ở gần bộ xử lý, tầng to và chậm ở xa. Chương trình nhanh khi dùng lại dữ liệu gần nhau. Nhớ nhé: dùng lại “cái gần” thì máy đỡ phải đi lấy “cái xa”.

    One idea used three times at three scales. Chapter 1 introduces caches and the L0–L6 hierarchy;1 Chapters 5 and 6 exploit locality to write fast code; Chapter 9 applies the same idea — a fast level caching a slow one — to main memory and disk as virtual memory.1

    Xuất hiện ở:Appears in: Ch 1, Ch 5, Ch 6, Ch 9

  4. Thread 04

    Biểu diễn bằng bit, và ngữ cảnh cho ý nghĩa Mọi thứ là 0 và 1; cách nhìn quyết định ý nghĩa Bits, and context giving meaning

    Chương 1 nêu nguyên lý: mọi thông tin là bit, và chỉ ngữ cảnh mới phân biệt một con số với một lệnh.1 Chương 2 biến nguyên lý đó thành cơ chế — số nguyên bù hai, dấu phẩy động, tràn số; Chương 3 cho thấy chính những bit ấy, nhìn dưới ngữ cảnh khác, là lệnh máy x86-64.1

    Bên trong máy chỉ có 0 và 1. Cùng một dãy, nhìn kiểu này là số, nhìn kiểu khác là chữ, là lệnh. Nhớ nhé: cùng một đống bit, đổi cách nhìn là đổi ý nghĩa.

    Chapter 1 states the principle: all information is bits, and only context distinguishes a number from an instruction.1 Chapter 2 turns the principle into mechanism — two's complement, floating point, overflow; Chapter 3 shows those same bits, under a different context, are x86-64 machine instructions.1

    Xuất hiện ở:Appears in: Ch 1, Ch 2, Ch 3

  5. Thread 05

    Hợp đồng giữa phần cứng và hệ điều hành Hệ điều hành đứng giữa chương trình và phần cứng The hardware–OS contract

    Chương 1 nói hệ điều hành chèn giữa chương trình và phần cứng, cung cấp ba trừu tượng: tiến trình, bộ nhớ ảo, và tệp.1 Ba trừu tượng ấy lần lượt là nội dung của Chương 8, Chương 9 và Chương 10 — mỗi chương mở ra một điều khoản của cùng một hợp đồng.1

    Chương trình của bạn không chạm thẳng vào phần cứng; hệ điều hành đứng giữa, đưa ra ba thứ dễ dùng: tiến trình, bộ nhớ ảo, và tệp. Nhớ nhé: ba thứ đó là ba “lời hứa” hệ điều hành dành cho mọi chương trình.

    Chapter 1 says the operating system sits between the program and the hardware, providing three abstractions: processes, virtual memory, and files.1 Those three are, in turn, the content of Chapters 8, 9 and 10 — each opening one clause of the same contract.1

    Xuất hiện ở:Appears in: Ch 1, Ch 8, Ch 9, Ch 10

  6. Thread 06

    Hiệu năng và song song Chạy nhanh hơn, và làm nhiều việc một lúc Performance and parallelism

    Mục 1.9 nêu định luật Amdahl — tăng tốc tổng thể bị chặn bởi phần được tăng tốc — và ba hình thức song song: mức luồng, mức lệnh, và SIMD.1 Chương 5 khai thác song song mức lệnh để tăng tốc một chương trình đơn luồng; Chương 12 khai thác song song mức luồng để làm nhiều việc cùng lúc.1

    Có hai cách cho máy nhanh hơn: làm mỗi việc gọn hơn, hoặc làm nhiều việc cùng lúc. Sách dạy cả hai, và cả giới hạn của chúng. Nhớ nhé: tăng tốc một phần nhỏ thì tổng thể cũng chỉ nhanh lên có hạn.

    Section 1.9 states Amdahl's law — overall speedup is capped by the fraction you speed up — and three forms of parallelism: thread-level, instruction-level, and SIMD.1 Chapter 5 exploits instruction-level parallelism to speed up a single-threaded program; Chapter 12 exploits thread-level parallelism to do many things at once.1

    Xuất hiện ở:Appears in: Ch 1, Ch 5, Ch 12

Lộ trình · 3 cách đọc Routes · three ways through

Ba lộ trình xuyên mười hai chương Nên đọc chương nào trước? Three routes through twelve chapters

Thứ tự 1→12 là lộ trình mặc định và là lộ trình tốt nhất cho lần đọc đầu — đó cũng là thứ tự môn “Nhập môn Hệ thống Máy tính” (Introduction to Computer Systems) tại Carnegie Mellon dùng, môn học mà cuốn sách được viết cho.23 Nhưng mỗi chương được viết khá độc lập, nên có thể đi theo ba đường khác nhau tuỳ mục tiêu. Cách phân nhóm dưới đây là gợi ý của trang này.

Đọc từ đầu đến cuối là cách chắc nhất, và cũng là thứ tự mà trường dạy. Nhưng nếu bạn đang cần một thứ cụ thể, có đường tắt. Nhớ nhé: được phép nhảy cóc, miễn là biết mình đang bỏ qua gì.

1→12 is the default route and the best one for a first pass — it is also the order of the "Introduction to Computer Systems" course at Carnegie Mellon, the course the book was written for.23 But each chapter is written fairly independently, so three different paths are possible depending on your goal. The grouping below is this page's suggestion.

Lập trình hệ thống, nhanh System programming, fast

1 → 2 → 3 → 7 → 8 → 10. Đường ngắn nhất để viết được mã chạm vào hệ thống: bản đồ tổng quan, biểu diễn số, hợp ngữ, liên kết, tiến trình và ngoại lệ, rồi vào/ra. Để dành Chương 4 và 6 (vi kiến trúc, cache) cùng Chương 11–12 cho lần sau.

Đọc 1, 2, 3, 7, 8, 10. Đây là bộ tối thiểu để viết chương trình nói chuyện được với hệ điều hành. Nhớ nhé: chưa cần đụng vi kiến trúc vội.

1 → 2 → 3 → 7 → 8 → 10. The shortest path to writing code that touches the system: the overview map, number representation, assembly, linking, processes and exceptions, then I/O. Save Chapters 4 and 6 (microarchitecture, caches) and Chapters 11–12 for later.

Hiệu năng là ưu tiên Performance first

1 → 3 → 4 → 5 → 6 → 12. Lộ trình “vì sao mã của tôi chạy chậm”: hợp ngữ để thấy trình biên dịch sinh ra gì, vi kiến trúc để hiểu đường ống, tối ưu, phân cấp bộ nhớ và tính cục bộ, rồi song song mức luồng. Đây là năm chương nặng nhất về tốc độ.

Đọc 1, 3, 4, 5, 6, 12. Đây là đường cho người muốn mã chạy nhanh hết mức. Nhớ nhé: tốc độ nằm ở bộ nhớ và cách viết, không chỉ ở thuật toán.

1 → 3 → 4 → 5 → 6 → 12. The "why is my code slow" route: assembly to see what the compiler emits, microarchitecture to understand the pipeline, optimization, the memory hierarchy and locality, then thread-level parallelism. These are the five chapters that weigh most on speed.

Đầy đủ, theo thứ tự sách Complete, in book order

1 → 2 → 3 → … → 12. Lần đọc đầu tốt nhất: đi đúng thứ tự tác giả dựng, vì mỗi chương chuẩn bị nền cho chương sau. Đây là thứ tự của giáo trình 15-213 tại Carnegie Mellon, nơi cuốn sách ra đời.3

Đọc lần lượt 1 đến 12. Chậm mà chắc, và đúng cách trường dạy. Nhớ nhé: lần đầu thì cứ đi thẳng theo số chương.

1 → 2 → 3 → … → 12. The best first read: go in the order the authors built, because each chapter prepares the ground for the next. This is the order of the 15-213 course at Carnegie Mellon, where the book was born.3

Khép lại bản đồ Closing the map

Mười hai chương không phải mười hai chủ đề. Chúng là một hành trình duy nhất — một chương trình đi từ dòng mã C, xuống tận bit và lệnh máy, rồi lại lên qua hệ điều hành để chạy, và cuối cùng bước ra ngoài để nói chuyện với cả thế giới.

Cả cuốn sách chỉ kể một điều: chuyện gì thật sự xảy ra bên dưới một dòng lệnh, từ lúc bạn gõ nó ra tới lúc nó chạy và gửi dữ liệu đi xa. Nhớ nhé: hiểu bên dưới một dòng lệnh là hiểu cả cái máy.

Twelve chapters are not twelve subjects. They are one single journey — a program travelling from a line of C, down to bits and machine code, back up through the operating system to run, and finally stepping outside to talk to the whole world.