Mobile System Design Interview · 第 3 章Triton 覆蓋度:🟡 中(只有 API/後端那一半)Triton 線

News Feed App
手機裡的那台冰箱

03 SDI 第 11 章講的是「後端怎麼把動態牆排好」。這一章換到手機那一端:畫面永遠從本地資料庫拿資料、網路只負責補貨;按讚先變色、背景再慢慢同步;滑得順不順,看的是 view 有沒有回收、圖片有沒有分級。Triton 沒有寫過 client 端,所以前大半照原書講白話版;最後幾頁才看他對 API 與後端的意見。

給文組

全程只用「家裡的冰箱」:冰箱 = 手機的本地 DB,菜市場 = backend,便利貼 = 還沒同步的按讚。一階一階爬 13 個概念;頁首標 延伸基礎 的頁是補基礎,懂的人可以跳過。

給工程師

原書 9 張圖全部依圖說重繪並可播放、5 張表與所有 data model 照列。後端的 fanout、feed cache 請看 03 SDI 第 11 章簡報,這裡不重講。

標籤怎麼看

📖 原書 🗣️ Triton 本人說 🔭 依 Triton 原則推論 📝 上課筆記 💬 討論串回覆

先用生活理解家裡的冰箱

肚子餓的時候,你先開冰箱,還是先叫外送?

如果每次肚子餓都叫外送,網路一慢就要等,颱風天外送停了就餓肚子。聰明的做法是:永遠從冰箱拿東西吃,菜市場(backend)有新貨就補進冰箱。

  • 冰箱 = 手機上的本地資料庫:畫面只從這裡拿資料(原書叫 Single Source of Truth)
  • 補貨 = 打 API 拿新貼文,先放進冰箱,再由冰箱通知畫面
  • 冰箱貼的便利貼 = 還沒送出去的按讚(第 35 頁的 queue)
  • 冰箱放不下 = 過期的要丟(第 31 頁的 eviction)
 
–看到第一則貼文花了多久–畫面狀態

學習地圖本章的概念階梯

今天爬 13 階。每一階只用前面講過的東西。

  1. 1API訂貨單
  2. 2cursor夾一張書籤
  3. 3requestId單子上的編號
  4. 4流量預算一個月 5 GB
  5. 5分層外場和廚房
  6. 6本地快取只看冰箱
  7. 7清冰箱LRU、TTL
  8. 8樂觀更新先說「好的!」
  9. 9backoff越等越久再打
  10. 10sanitize海報先檢查
  11. 11main thread唯一的服務生
  12. 12lazy loading菜一道一道上
  13. 13304「沒改」

第 1–4 階 · 手機怎麼跟菜市場訂貨

要回答:要什麼、一次拿多少、斷線重送怎麼辦、流量怎麼省?

第 5–7 階 · 家裡的冰箱

要回答:手機裡誰管什麼?畫面為什麼只看冰箱?滿了丟什麼?

第 8–10 階 · 按讚和發文

要回答:按讚為什麼不用等?失敗怎麼辦?別人的貼文怎麼安全顯示?

第 11–13 階 · 滑得順、省流量

要回答:為什麼會卡?圖片何時下載?第二次還要整份重拿嗎?

全程只用一個情境:家裡的冰箱

手機 app = 家冰箱 = 本地資料庫菜市場 = backend巷口的分店倉庫 = CDN訂貨單 = API request書籤 = cursor冰箱門上的便利貼 = 還沒同步的按讚管家 = Repository

原書的數字照用:一頁 30 則、冰箱最少留 50 則、TTL 15 天。每爬 3–4 階有一頁「到這裡你已經會了」。

原書開頭什麼是 news feed · Figure 1

一條不斷更新、可以一直往下滑的清單

這一步要解決的問題「news feed」到底是什麼?先對齊大家腦中的同一個畫面。

📖 原書 Facebook News Feed、X(前身 Twitter)Timeline、Instagram Feed 都是同一件事:持續更新的內容項目列表,內容可能是狀態、照片、影片、連結,讓使用者一直滑下去。

📖 原書 大多數 news feed 共有的功能

  • 可以滾動的內容清單
  • 點進單篇貼文看詳細內容
  • 無限滾動(endless scrolling)
  • 按讚、留言、分享這類社交互動

核心結構很像,但內容類型和面試官的需求不同,技術做法就會不同。原書接下來一步一步設計。

📖 原書 Figure 1典型的 news feed app(依原書內容重繪;原圖是線框示意,沒有文字)

四則一樣的卡片:大頭貼圓圈、一條橫條、愛心、向上箭頭(分享),內容是圖片或影片播放鍵。

原書 Step 1了解問題、確定範圍

面試一開始:應徵者 × 面試官的七個來回

這一步要解決的問題要做多大、哪些功能、哪些不做?沒問清楚就畫圖,很容易畫錯。

應徵者問面試官答
只做 mobile,還是要考慮共用同一個 backend 的 web、穿戴裝置?今天重點是 mobile,但未來可能有其他 client
功能:看 feed、分享和按讚、看貼文詳情、發新貼文;feed 無限滾動、滑到底再載入;貼文照 server 給的順序顯示。對嗎?完全正確
貼文只有文字,還是可以有照片、影片?文字加圖片、影片附件;而且要支援 rich text(標題、粗體、斜體)
即時功能呢?分享數、按讚數即時更新?親密好友發文的推播?簡化起見,不做即時更新和通知
規模多大?使用者分布在哪?目標很大:5 億 MAU,分布全球
全球各地網路品質不一,要不要離線模式看之前載入的內容?要不要 pre-fetch 加快首次載入?離線模式要,好主意;pre-fetch 這次先不做
要設計登入驗證嗎?還是假設已登入?假設已經驗證過

白話:MAU=每個月有打開 app 的人數;rich text=有標題、粗體、斜體的文字;pre-fetch=使用者還沒打開就先下載;backend=菜市場那一端的 server。

📖 原書 對話還可以繼續談其他相關主題;透過來回討論,把要設計的東西講清楚,然後整理成需求(下一頁)。

原書 Step 1Requirements

需求清單:點一條,看它在哪一頁被解決

這一步要解決的問題把對話整理成清單:每一條後面都要有一頁回答它。

📖 原書 Functional

  • 瀏覽來自他人的貼文 feed
  • 直接在 feed 裡按讚、分享
  • 撰寫含 rich text、圖片、影片的貼文
  • 點貼文開啟詳細頁
  • 無限滾動:往下滑就抓更多貼文
  • 離線模式:沒網路也能看之前載入的內容

📖 原書 Non-functional

  • Scalability:全球 5 億 MAU,適應各種網路
  • Performance:滑動流暢、發文有效率、各種裝置的媒體處理都優化
  • Reliability:網路差也能用,靠快取支援離線
  • Data efficiency:智慧快取、選擇性載入,替流量有限的人省流量
  • Consistency:離線操作要 eventual consistency,恢復連線後可靠同步

📖 原書 Out of scope

  • 即時更新與推播通知
  • 使用者打開 app 前先 pre-fetch 貼文
  • Authentication(假設已登入)

白話:Scalability=人變多也撐得住;eventual consistency=先各記各的,過一陣子對齊;Authentication=確認你是誰(登入)。

點左邊任一條需求,這裡會告訴你它在第幾頁。

原書 Step 1UI sketch · Figure 2

三個畫面:動態牆、貼文詳情、建立貼文

這一步要解決的問題先畫出三個畫面,才知道 API 要提供哪些資料。

📖 原書 News/Posts Feed 是 app 的核心:無限的貼文清單,可以直接按讚、分享;點貼文開詳細頁;右下角的 Floating Action Button(FAB)用來發新貼文。

📖 原書 Create Post:用 rich text、圖片、影片撰寫新貼文。

📖 原書 Post Detail:選中貼文的完整內容,也能按讚、分享。

界定問題、勾勒體驗之後,下一步是支撐這些功能的 API 設計。

📖 原書 Figure 2三個畫面與彼此的關係(依原書內容重繪;alt 寫的箭頭是左→中、中→右,這裡依內文畫成從動態牆出發)

延伸基礎第 1 階 · API懂的人可以跳過

  1. API
  2. cursor
  3. requestId
  4. 流量預算
  5. 分層
  6. 本地快取
  7. 清冰箱
  8. 樂觀更新
  9. backoff
  10. sanitize
  11. main thread
  12. lazy loading
  13. 304

手機想看新貼文:要怎麼跟菜市場「訂貨」?

① 先想像

打電話隨口說「老闆,上次那個」,老闆常聽錯。改成一張固定格式的訂貨單,就不會錯。

你猜猜看:打開 app 看動態,是誰先開口?

③ 這叫做 API、JSON

API:菜市場公開的訂貨窗口和單子格式,例如 GET /v1/feed。JSON:單子的寫法,"欄位": 值 一格一格填。

④ 跟這章的關係

第 9–18 頁的四支 API,就是這家店的訂貨單。每送出一張叫一個 request(03 第 4 章第 4 頁)。

② 動手玩:三張訂貨單


      

原書 Step 2API design · Communication protocol · Figure 3 · Table 1

全部都是 client 先開口,所以選 HTTP + REST

這一步要解決的問題手機和 backend 要用什麼方式講話?先看是誰先開口。

📖 原書 Figure 3client 發起的四種 request(依原書內容重繪)

📖 原書 四種互動:Feed retrieval(開 app 拿近期貼文)、Post creation、Post details(點貼文拿更多)、User interactions(按讚、分享通知 backend)。API 設計要談三件事:通訊協定、endpoints、其他考量。

白話:REST=用網址當名詞(/v1/feed)、GET/POST 當動詞的 API 風格;stateless=server 不記得上一張單,每張單自己帶齊;over-fetching/under-fetching=拿太多/拿太少要多跑幾趟;persistent connection=一直開著不掛的線。

📖 原書 Table 1 HTTP with REST

優點缺點
廣泛使用、大家都懂,實作與維護容易API 演進時版本管理麻煩;沒有好的 versioning 策略,API 會變臃腫
Server stateless:每個 request 自帶處理所需資訊,水平擴展與多 client 都簡單Stateless = 每次都帶 auth token 等資訊;沒有 persistent connection 時,多出來的流量和建連延遲會影響 mobile 效能
可以用 HTTP caching 減輕 server 負擔、加快回應可能 over-fetching(拿太多)或 under-fetching(要打好幾次)

Table 1 的「server stateless」和「HTTP caching」兩格,Triton 都有更精確的說法(第 54、52 頁)。

原書 Step 2GraphQL?資料編碼 · Table 2

JSON、XML、Protocol Buffers:選 JSON

這一步要解決的問題訂貨單上的內容,要用哪一種寫法?

📖 原書 也可以用 GraphQL:client 在一個 request 裡指定要哪些欄位,避免 over-fetching。但本章聚焦 HTTP + REST,業界例子有 Meta Graph API、Reddit API、X API。

📖 原書 Table 2 網路資料編碼的取捨

JSON可讀、比 XML 小;多數語言原生支援,常和 REST 一起用
XML我們的 request 不需要帶太多 metadata,所以 JSON 比 XML 好
Protocol Buffers可能是不錯的選擇;但這次不追求極致效能,用 JSON 免去高昂的設定成本

✅ 原書的決定

  • HTTP with REST APIs
  • JSON 當資料格式(熟 Protobuf 的話,用它設計 API 也很好)

白話:GraphQL=client 自己列出要哪些欄位的查詢語言;XML=每一格都用開始、結束標籤包起來;Protocol Buffers=只寫欄位編號的二進位格式,小但人看不懂;metadata=描述資料的資料。

動手比:同一則 PostPreview 用三種格式送


      

JSON、XML 是實際算出的位元組數;Protobuf 依 wire format(欄位 tag + varint + 長度前綴字串)估算。文組翻譯:同一份菜單,XML 是每道菜都寫「開始:菜名… 結束:菜名」,Protobuf 是只寫編號。

原書 Step 2API endpoints · Feed retrieval

GET /v1/feed?after=<some-value>&limit=30

這一步要解決的問題打開 app 要拿 feed:這張單子長什麼樣、要帶哪些欄位?

Authentication: Bearer <token>
GET /v1/feed?after=<some-value>&limit=30
  Body: empty
  Response: 200 OK. Payload of type FeedApiResponse

📌 原書 Remember endpoint 帶版本(/v1/),新版本才能引入 breaking change、舊版保持穩定,並有計畫地淘汰 API(詳見第 10 章 Building Blocks)。

📖 原書 PostPreview 以效率為核心:只拿夠用的資料,不拿全部附件,只拿附件數量和一張預覽縮圖 URL;也帶「我按過讚沒」這類互動細節。

🛠️ 原書 平台實作 書裡用 Kotlin/Swift data model 呈現回應;實務上 JSON 在 network data source 轉成平台結構:Android 用 kotlinx.serialization、Moshi;iOS 用 Codable。

📖 Other headers 有 Authentication header 表示要登入才能呼叫;用 JSON,所以預設都帶 Accept: application/json。

白話:Bearer token=登入後拿到的通行證,每張單都附上;header=單子上方的小標籤;data model=一則貼文有哪些欄位的清單;breaking change=會讓舊 app 壞掉的改版。

📖 原書 data model
data class FeedApiResponse
  feed: List<PostPreview>
  paging: PaginationMetadata

data class PostPreview
  postId: Long
  contentSummary: String
  author: AuthorPreview
  createdAt: String
  liked: Boolean
  likeCount: Int
  attachmentCount: Int
  attachmentPreviewImageUrl: String?

data class AuthorPreview
  id: Long
  name: String
  profileImageThumbnailUrl: String

注意 author 是整個嵌進每一則貼文的。後端要怎麼一次把 30 個作者補齊,見第 53 頁。

延伸基礎第 2 階 · cursor懂的人可以跳過

  1. API
  2. cursor
  3. requestId
  4. 流量預算
  5. 分層
  6. 本地快取
  7. 清冰箱
  8. 樂觀更新
  9. backoff
  10. sanitize
  11. main thread
  12. lazy loading
  13. 304

一次只搬 30 則回家:滑到哪裡,再去拿下一批?

① 先想像

菜市場有幾億則貼文,手機一次只搬 30 則。看完了,拿著書籤回去說:「這一則之後,再給我 30 則。」

你猜猜看:每秒滑過 6 則,拿一批要 1 秒。什麼時候出門最好?

③ 這叫做 pagination、cursor

pagination:分頁,一次只給一批。cursor:書籤,記「上次看到哪一則」。

④ 跟這章的關係

原書 GET /v1/feed?after=…&limit=30 的 after 就是書籤(第 13 頁)。後端那一側見 03 第 11 章第 26 頁。

② 動手玩:滑完 90 則(3 批)

–盯著轉圈的時間–拿了幾批(request)–現在

每秒滑過 6 則、拿一批要 1 秒,動畫加速 3 倍。看過 已在手機上 正在拿 還沒拿

原書 Step 2Pagination

一邊往下滑,一邊有人發新貼文

這一步要解決的問題一邊滑、一邊有人發新文:下一頁要怎麼拿,才不重複、不漏掉?

📖 原書 無限滾動清單需要分頁(第 10 章比較了各種分頁)。Offset 分頁在頻繁更新的內容上會出問題:滑越深查詢越慢,而且新貼文一加進來,內容視窗就不準了。

📖 原書 Cursor-based 比較適合,因為它

  • 用有 index 的欄位,不用計算 offset,大資料量更有效率
  • 用唯一識別碼維持穩定排序,feed 一致性更好
  • 適合不斷變動的即時內容

✅ 原書的決定:feed retrieval endpoint 用 cursor-based pagination。
文組翻譯:offset 是「從第 10 頁開始讀」,可是有人在書的最前面插了兩頁,你的第 10 頁就變了;cursor 是夾書籤,「從這則貼文之後繼續讀」。

offset

cursor

延伸基礎第 3 階 · requestId懂的人可以跳過

  1. API
  2. cursor
  3. requestId
  4. 流量預算
  5. 分層
  6. 本地快取
  7. 清冰箱
  8. 樂觀更新
  9. backoff
  10. sanitize
  11. main thread
  12. lazy loading
  13. 304

電話斷了,老闆到底聽到沒?再打一次會不會送兩份?

① 先想像

你打電話訂 1 箱蘋果,講完訊號斷了。不知道老闆有沒有聽到,只好再打一次。

你猜猜看:老闆其實第一次就聽到了。重打時單子上沒寫編號,會送來幾箱?

③ 這叫做 requestId、idempotency

requestId:手機自己寫在單子上的編號。idempotency:同一張單送幾次,結果都跟送一次一樣。

④ 跟這章的關係

原書的發文、按讚都帶 requestId(第 15、18 頁)。完整版見 03 第 26 章第 32 頁。

② 動手玩:訂蘋果


      
0你真正想要的箱數0老闆送來的箱數

原書 Step 2Post creation

POST /v1/posts:附件先上傳,再發文

這一步要解決的問題發一篇有照片的貼文:大檔案怎麼送?斷線重送會不會多一篇?

Authentication: Bearer <token>
POST /v1/posts
  Body: NewPostRequest
  Response: 201 Created

📖 原書 取資料用 GET,送新資訊用 POST。Server 回 201 表示建立成功,但 response body 不帶任何資料。

data class NewPostRequest
  requestId: Long
  content: String
  attachments: List<NewAttachment>

data class NewAttachment
  type: String
  contentUrl: String
  caption: String?

📖 原書 client 送的 requestId 不是 server 指派的 postId。postId、created_at 由 backend 產生,backend 才是關鍵資料的 source of truth(第 19 頁)。

📖 原書 附件假設已經先上傳到我們的 server,contentUrl 只放上傳後的 URL。兩階段(先傳附件、再建貼文)處理大檔比較有效率。


      

延伸基礎第 4 階 · 流量預算懂的人可以跳過

  1. API
  2. cursor
  3. requestId
  4. 流量預算
  5. 分層
  6. 本地快取
  7. 清冰箱
  8. 樂觀更新
  9. backoff
  10. sanitize
  11. main thread
  12. lazy loading
  13. 304

手機一個月只有 5 GB:每一張圖都在花錢、花電

① 先想像

很多人的方案一個月只有幾 GB,用完就變超慢。電池也一樣:每叫網路起來一次,就扣一點電。

你猜猜看:每天滑 200 則,每則下載一張 1 MB 原圖,一個月(30 天)用掉多少?

③ 這叫做 data efficiency、thumbnail

data efficiency:用最少的流量做完同一件事。thumbnail:縮圖,清單上那張小圖。

④ 跟這章的關係

原書的非功能需求就有 Data efficiency:清單只給縮圖,點了才給原圖(第 17 頁);網路差就降畫質(第 47 頁)。

② 動手玩:一個月的帳單

–一天–一個月(30 天)–佔月額度–每天叫醒網路幾次

「叫醒網路」:手機的網路晶片平常在睡,每拿一次資料都要醒來、撐一下才睡回去,所以一次拿一批比一則一則拿省電。數字都是示意。

原書 Step 2Post details · list-detail 兩種 model

GET /v1/posts/{postId}:清單給縮圖,點進去才給全部

這一步要解決的問題清單要很多則、詳情要很完整:同一份資料要不要分兩種大小?

Authentication: Bearer <token>
GET /v1/posts/{postId}
  Body: empty
  Response: 200 OK. Payload of type PostDetailApiResponse
依 REST,路徑裡的 postId 指出要哪一個資源
data class PostDetailApiResponse
  post: PostDetail
data class PostDetail
  postId: Long        content: String
  author: AuthorPreview   createdAt: String
  liked: Boolean      likeCount: Int
  shareCount: Int     attachments: List<Attachment>
data class Attachment
  id: Long  type: String  contentUrl: String
  previewImageUrl: String?  caption: String?

📌 原書 Remember 同一份內容,兩種 model

  • 清單用輕量 model(PostPreview):夠好的清單體驗就好,用縮圖或低解析度省頻寬
  • 詳細頁用完整 model(PostDetail):全部細節與高解析度圖片,使用者點了表示有興趣才載入

兩層做法同時替 client 和 server 省網路、運算、記憶體,對低階手機尤其重要。文組翻譯:菜單上放小照片,客人點了才把整道菜端出來。

–總共下載(示意)–清單佔的記憶體(示意)

假設:PostPreview 1 KB + 縮圖 30 KB;PostDetail 3 KB + 平均 3 張原圖各 400 KB。數字是示意,不是原書的。

原書 Step 2User interactions with a post

POST /v1/posts/{postId}/interactions

這一步要解決的問題按讚、取消讚、分享:怎麼告訴 backend,又不讓人冒充別人按讚?

Authentication: Bearer <token>

POST /v1/posts/{postId}/interactions
  Body: PostInteractionRequest
  Response: 201 Created
data class PostInteractionRequest
  requestId: Long
  type: String

📖 原書 和 post creation 一樣的模式。type 可以是 enum:LIKED、REMOVED_LIKE、SHARED。requestId 通常是 client 產生的隨機 UUID,幫 backend 辨認唯一 request,但不長期保存。

白話:enum=只能從幾個固定選項挑一個;UUID=一串幾乎不會撞號的隨機編號;auth token=登入通行證,裡面寫了你是誰。

📝 原書 Note request 裡不放 userId

Backend 從 auth token 取出 userId。省頻寬、避免重複資料,也避免「request 裡的 userId 和 token 對不上」的資安問題。

動手試:組一個 request


      

原書 Step 2Additional considerations:ID 與時間戳由誰產生

為什麼不讓手機自己決定 postId 和 created_at?

這一步要解決的問題貼文的編號和發文時間,該由誰說了算?

📖 原書 建立貼文時刻意不送 postId 和 created_at。大規模下,把 ID 與時間戳集中在 backend 產生有四個好處:

  1. Consistency:backend 能對所有 client 強制統一格式與驗證規則
  2. Reliability:手機的系統時鐘可能不準,甚至被竄改
  3. Uniqueness:高交易量下也保證 ID 唯一不碰撞
  4. Database integration:用 DB 的 auto-increment 與 CURRENT_TIMESTAMP,在 insert 時有效率地產生

📖 原書 很多公司有專門的大規模 ID 機制,例如 X 的 Snowflake ID:分散式、以時間為基礎,維持順序又不會跨機器碰撞。使用者成長到數億時,這個可靠的基礎越來越重要。

Triton 對 auto-increment 與 Snowflake 的看法在 03 SDI 第 7 章簡報(010、094、113),這裡不重講。白話:auto-increment=資料庫自動發 1、2、3 號;Snowflake ID=用時間加機器編號拼成、不會撞號的號碼。

動手試:三支時鐘不準的手機

阿明的手機準時;小美的手機慢 5 分鐘;阿豪的手機快 3 分鐘。依序按下去(真實順序就是你按的順序)。

用手機時間排序

    用 server 時間排序

      到這裡你已經會了小結 1 / 4

      1. API
      2. cursor
      3. requestId
      4. 流量預算
      5. 分層
      6. 本地快取
      7. 清冰箱
      8. 樂觀更新
      9. backoff
      10. sanitize
      11. main thread
      12. lazy loading
      13. 304

      到這裡你已經會了:手機怎麼跟菜市場訂貨

      下一階要解決的問題

      訂貨單設計好了。貨送到家之後,手機裡誰負責收、放哪裡、怎麼給畫面?這是原書 Step 3 的 client 架構。

      延伸基礎第 5 階 · 分層懂的人可以跳過

      1. API
      2. cursor
      3. requestId
      4. 流量預算
      5. 分層
      6. 本地快取
      7. 清冰箱
      8. 樂觀更新
      9. backoff
      10. sanitize
      11. main thread
      12. lazy loading
      13. 304

      外場和廚房分開:菜市場搬家,服務生要重新訓練嗎?

      ① 先想像

      餐廳外場只管上菜、收單;廚房管冰箱和採買。外場從不自己跑菜市場。

      你猜猜看:菜市場搬家了(backend 換網址),誰要改?

      ③ 這叫做 layer、repository

      layer:分層,外場叫 UI layer、廚房叫 data layer。repository:廚房的管家,外場要什麼都找他。

      ④ 跟這章的關係

      原書 Figure 4 就是這兩層(第 22 頁);每種資料一個 Repository(第 24 頁)。

      ② 動手玩:改一個地方,要動幾個元件?

      原書 Step 3High-level client architecture · Figure 4

      整支 app 的骨架:箭頭是資料怎麼流,不是誰依賴誰

      這一步要解決的問題手機裡有哪些零件?資料從哪裡進來、怎麼一路流到畫面?

      📖 原書 Figure 4News feed 高階行動架構(依原書內容重繪)

      📖 原書 這一步要涵蓋:高階架構、外部 server 端元件、UI 層與 Data 層的主要元件、跨層的資料流。

      重要:原書特別說明,圖中箭頭代表資料流,不是元件依賴。資料從 Posts DB 與 Backend 經過 data source、repository,透過 dependency injection 上到 state holder,最後到畫面。

      白話:data source=負責從某個地方拿資料的人;state holder=決定畫面顯示什麼的人;dependency injection(DI)=零件不自己去找別的零件,由外面統一配好遞給它;HTTPS=加密過的 HTTP。

      原書 Step 3External components · Client architecture

      外面有兩個幫手;裡面分成 UI 層和 Data 層

      這一步要解決的問題外面有誰幫忙?手機裡面要怎麼分工?

      📖 原書 Backend

      RESTful 服務,用 HTTPS + JSON 和 app 溝通。兩個主要功能:提供 app 要的資料(貼文、使用者資訊)、永久儲存貼文與互動。系統大部分商業邏輯在這裡:feed 產生、建立貼文、處理互動。

      📖 原書 CDN

      • 不管使用者在哪,feed 都快速且穩定地載入
      • 減輕 server 負載,流量高峰或重大事件時特別有用
      • 從物理上更近的 server 提供內容

      5 億 MAU、大量靜態內容(頭像、媒體附件),加 CDN 是明智選擇;由 backend 負責提供 CDN 要分發的內容。

      💡 原書 Pro tip 用你最熟的模式(repository、Clean Architecture、MVVM、MVI、MVP)。重點不是哪一種,是你能多清楚講出理由、示範資料怎麼流。

      ✅ 決定:UI + Data 的分層架構;UDF 與 Reactive programming。

      📖 原書 兩層架構

      • UI layer:顯示貼文、處理互動、替畫面準備資料
      • Data layer:app 的骨幹,處理 client 端貼文的商業邏輯:在裝置上怎麼建立、修改、取得貼文

      📖 原書 UDF + Reactive programming

      Unidirectional Data Flow:資料單向往上流(data source → repository → UI),使用者動作走明確的通道反向往下。Reactive programming 提供處理非同步資料流、傳播變更的工具。再加上 separation of concerns、single responsibility,用 dependency injection 保持鬆耦合。

      🛠️ Android:Kotlin Coroutines + Flow;iOS:Combine。

      原書 Step 3Data layer

      每種資料一個 Repository,加上零到多個 Data Source

      這一步要解決的問題手機裡的資料怎麼分工:誰去拿、誰保管、誰對外?

      📖 原書 設計 data layer 先看 app 處理哪些資料。每一種資料通常有:

      • 一個 Repository:該資料的主要介面,對外暴露資料、處理相關商業邏輯
      • Data Sources:負責特定的資料操作,看需要從哪裡拿、存到哪裡,可能零個到多個

      📖 原書 本章主要的資料是 Posts:

      冰箱比喻

      💡 原書 Pro tip Data layer 同時有 client 端商業邏輯與 app 資料,是最關鍵的一層;多花時間在這裡,面試官會看到你懂穩健的資料管理。

      💡 原書 Pro tip 畫高階架構圖時聚焦最關鍵的部分,不用解釋 UI 層、Data 層是什麼;優先講你的關鍵決策與取捨,面試官想知道更多會追問。

      這樣分層的好處:職責清楚、模組化、好維護;未來要加 user profile、analytics 這類資料,照同一個模式加就好。

      原書 Step 3UI layer · State Holder

      每個畫面配一個 State Holder:決定畫面上要顯示什麼

      這一步要解決的問題畫面要顯示貼文、轉圈還是錯誤訊息,由誰決定?

      📖 原書 三個主要畫面:News Feed、Post Detail、Create Post。每個畫面有一個 State Holder(想成 Android 的 ViewModel),兩個功能:

      • 管理 UI state:決定畫面上要顯示哪些資料
      • 處理畫面邏輯:處理互動、轉換資料、和 data layer 協調取得與修改 app state

      📖 原書 用 News Feed 當例子:State Holder 自動訂閱 Posts Repository,透過 NewsFeedUiState stream(observable data holder)暴露給 UI。除了貼文,UI state 還可能有錯誤訊息、loading 指示等。

      💡 原書 Pro tip Step 3 不必追求完美:這是骨架不是藍圖,看好時間,別陷進細節。

      data class NewsFeedUiState
        feed: List<PostPreviewUiModel>
        isLoading: Boolean
        errorMessage: String?

      📝 原書 Note 為什麼是 PostPreviewUiModel,不是 PostPreview?

      刻意的:把 domain/data model 和 UI model 分開。UI 通常只要一部分資料,有時還要重新整形或預先處理,才能有效率地畫出來。這讓 UI 精簡、少用記憶體,畫面也能獨立於後端或儲存方式演進。越靠近 UI 的 model,越該長成 UI 需要的樣子,而不是資料怎麼存的樣子。

      原書 Step 3Navigation · Figure 5 · Media Loader

      點一則貼文:畫面只告訴 Navigator「要開哪一篇」

      這一步要解決的問題點一則貼文時,畫面怎麼換?貼文裡的圖片又由誰負責載?

      📖 原書 Figure 5開啟貼文詳情的資料流(依原書內容重繪)

      📖 原書 串起各畫面的是 Navigation 元件:管理使用者在畫面間移動,並傳遞必要資訊,例如開 Post Detail 時的 postId。導覽事件由 UI 元件直接處理:使用者點貼文 → News Feed Screen 通知 Navigator 下一個畫面與 postId。這在 event-based 導覽函式庫很常見。

      📖 原書 State Holder 也管按讚、分享:委派給 Posts Repository 處理資料變更;若用 optimistic writes,state holder 立刻更新 UI state,給使用者即時回饋(第 35 頁)。

      📖 原書 Media Loader(UI 層共用元件)

      貼文附件在 data model 裡只是 URL 字串。Media Loader 負責從 CDN 下載並管理圖片與其他媒體:集中處理,全 app 一致,並提供最佳化的快取、載入、錯誤處理;也能做漸進式載入或佔位圖(第 47 頁可以玩)。

      延伸基礎第 6 階 · 本地快取懂的人可以跳過

      1. API
      2. cursor
      3. requestId
      4. 流量預算
      5. 分層
      6. 本地快取
      7. 清冰箱
      8. 樂觀更新
      9. backoff
      10. sanitize
      11. main thread
      12. lazy loading
      13. 304

      家規:吃的只從冰箱拿,買回來先放冰箱

      ① 先想像

      兩個房間各自打電話問「還有幾顆蛋」,一個問到 12、一個問到 11,就吵起來。大家只看冰箱,就不會吵。

      你猜猜看:動態牆和貼文詳情各自打網路拿讚數,可能看到什麼?

      ③ 這叫做 local cache、SSOT

      local cache:手機上的冰箱(本地資料庫)。SSOT(single source of truth):畫面只認一個正本。

      ④ 跟這章的關係

      原書:網路拿到的先寫進本地 DB,再由 DB 通知畫面(第 28 頁);沒網路也有東西看(第 32 頁)。cache 見 03 第 1 章第 18 頁。

      ② 動手玩:兩個畫面、一個讚數

      原書 Step 3Data flow across app layers · Figure 6

      第一次登入:13 步,資料先進冰箱,再上畫面

      這一步要解決的問題第一次登入、冰箱還是空的:資料怎麼一路走到畫面?

      📖 原書 Figure 6使用者登入資料流(依原書內容重繪,步驟號碼照原圖)

      按「下一步」從 1 開始

        💡 原書 Pro tip 往下之前,停下來確認前面的功能與非功能需求都涵蓋了,現在補比深入技術討論時再補容易得多。

        原書 Step 4Design deep dive · Local storage · Table 3

        深入四個主題,第一個:手機上的冰箱要用哪一種?

        這一步要解決的問題冰箱要用哪一種?要能查、能排序,而且不能亂掉。

        📖 原書 Step 4 要深入的四塊

        1. Local storage 與離線模式(第 29–32 頁)
        2. Optimistic writes 與離線互動(35–39)
        3. 顯示 rich post content(41–42)
        4. 排查卡頓的 feed 捲動(45–47)

        📖 原書 本地儲存的兩個用途:離線瀏覽、抵抗爛網路(訊號不穩時還能滑先前快取的貼文);提升效能(開快取過的貼文詳情是瞬間的,不用發網路 request)。資料庫內容和媒體都需要資料管理策略:儲存與清除政策、離線體驗、媒體快取。

        💡 原書 Pro tip 對大多數 mobile app,relational database 是儲存 app 資料的首選:內建擴展性、平台支援強、工具成熟。除非有特定需求,否則就當它是預設起點。

        白話:relational database=有表格、有目錄、能複雜查詢的資料庫;transaction=幾個動作要嘛全做、要嘛全不做;key-value store=只有編號的置物櫃。

        📖 原書 Table 3 在裝置上存貼文的取捨

        Relational DB貼文是結構良好的 data model,需要複雜關聯與進階查詢:篩選、排序、可能還要搜尋。提供資料完整性與一致性,設計上能有效擴展。
        Non-relational DB貼文結構良好,享受不到 non-relational 的優勢;我們要複雜查詢,本地儲存也不能有不一致。
        Key-value stores不是設計來處理大量資料或複雜結構;沒有關聯結構會造成資料重複;存太多會變慢;不支援關聯、進階查詢、transaction。

        ✅ 原書的決定:relational database,結構化儲存、查詢能力與 transaction 是離線功能需要的組合。

        (原書沒有點名產品;Android 常見的是 SQLite/Room,iOS 是 SQLite、Core Data 或 SwiftData。)

        延伸基礎第 7 階 · 清冰箱懂的人可以跳過

        1. API
        2. cursor
        3. requestId
        4. 流量預算
        5. 分層
        6. 本地快取
        7. 清冰箱
        8. 樂觀更新
        9. backoff
        10. sanitize
        11. main thread
        12. lazy loading
        13. 304

        冰箱只有 8 格:滿了,要丟哪一樣?

        ① 先想像

        新買的菜要放進去,總得丟一樣。過期的先丟;沒過期的,丟最久沒打開的。但颱風天要有存糧,最少留幾樣。

        你猜猜看:冰箱滿了,要放新買的牛奶,該丟哪一樣?

        ③ 這叫做 LRU、TTL

        LRU(least recently used):最久沒用的先丟。TTL(time to live):保存期限,過期就丟。

        ④ 跟這章的關係

        原書:LRU + TTL 15 天 + 最少留 50 則(第 31 頁)。後端快取的 TTL 見 03 第 11 章第 35 頁。

        ② 動手玩:保存期限 14 天、最少留 3 樣

        原書 Step 4Database eviction policy

        冰箱放不下了:LRU + TTL + 最低門檻

        這一步要解決的問題冰箱放不下了:留哪些、丟哪些?

        📖 原書 新內容源源不絕,無限期存每一則貼文既沒效率又浪費裝置資源。混合三種互補的策略:

        • LRU:優先保留使用者最近看過的,最可能再被打開
        • TTL:每則貼文有到期時間,快取裡不放過期內容
        • Custom minimum threshold:永遠保留一定數量供離線看

        📖 原書 起始預設值

        • 最大快取:100–200 MB,依使用模式調整
        • 預設 TTL:一般貼文 15 天
        • 最低門檻:50 則,或約 2–3 個畫面的量

        這些參數應該可以從 backend 設定,依真實的分析數據微調。

        0保留0TTL 過期刪除0超過容量,LRU 刪除0過期但被門檻保住0佔用 MB

        原書 Step 4Offline mode user experience · SSOT

        沒網路時打開 app:看到的是冰箱裡的東西

        這一步要解決的問題沒網路時打開 app,畫面上要有什麼?登出之後呢?

        📖 原書 遵循 Single Source of Truth:從 backend 收到貼文就立刻存進本地 DB。Posts Repository 不管有沒有網路,一律從 local data source 暴露貼文 stream。資安考量:DB 只屬於目前的使用者,登出就清空。

        📌 原書 Remember SSOT

        • 所有 UI 元件只從本地 DB拿資料,絕不直接從網路
        • 網路回應更新本地 DB,再由 DB 把變更傳到 UI
        • 使用者互動先記在本地 DB,再送去 server

        Backend → Local Storage → UI

        📖 原書 離線時下拉重新整理:① Repository 試著從 remote 拿 ② 連線問題,失敗 ③ 失敗傳到 state holder,更新 UI state ④ UI 顯示連線問題的訊息 ⑤ 先前快取的內容繼續顯示。

        🔍 原書 Industry insights Facebook iOS 早期用 Core Data 快取 feed,規模大了變慢,改成輕量、非正規化、用物件序列化的磁碟快取;Instagram 有 feed JSON 的 response store 與圖片/影片快取,離線時像從網路拿一樣從磁碟給;Reddit 在部分裝置上發現外部儲存不可靠,改用 Android 內部儲存快取影片。

         

          到這裡你已經會了小結 2 / 4

          1. API
          2. cursor
          3. requestId
          4. 流量預算
          5. 分層
          6. 本地快取
          7. 清冰箱
          8. 樂觀更新
          9. backoff
          10. sanitize
          11. main thread
          12. lazy loading
          13. 304

          到這裡你已經會了:家裡的冰箱

          下一階要解決的問題

          「讀」的部分完成了。按讚、發文這種「寫」,要怎麼做才不用盯著網路等?

          延伸基礎第 8 階 · 樂觀更新懂的人可以跳過

          1. API
          2. cursor
          3. requestId
          4. 流量預算
          5. 分層
          6. 本地快取
          7. 清冰箱
          8. 樂觀更新
          9. backoff
          10. sanitize
          11. main thread
          12. lazy loading
          13. 304

          按讚之後,要等菜市場回話才變紅嗎?

          ① 先想像

          點餐時服務生聽完就說「好的!」,不會站著等廚房回話。萬一真的沒料了,再回來道歉。

          你猜猜看:網路來回要 2 秒。等 server 確認才變紅,按讚後多久才看到紅心?

          ③ 這叫做 optimistic update、rollback

          optimistic update:樂觀更新,先當作會成功、立刻改畫面。rollback:真的失敗了,再把畫面改回來。

          ④ 跟這章的關係

          原書的 optimistic writes 與 Figure 8(第 35、39 頁):按讚先變紅,便利貼排隊,背景再同步。

          ② 動手玩:兩顆愛心,同時按

          等 server 確認才變

          ♡

          –

          樂觀更新:先變再說

          ♡

          –

          右邊不是「假裝成功」:按讚記在冰箱門的便利貼上(第 6 階的冰箱),背景再告訴菜市場。

          原書 Step 4Optimistic writes · Data layer updates

          按讚先變紅,背景再慢慢告訴 server

          這一步要解決的問題按讚為什麼不用等網路?離線時按的讚怎麼辦?

          📖 原書 Optimistic writes:使用者一動作就立刻更新 UI,不等 backend 確認,感覺立刻生效;對低階手機、爛網路地區的參與度與留存特別重要。處理這類 UI 事件(例如按讚),state holder 平行做兩件事:

          1. 立刻更新 UI state,彷彿 data layer 已確認:這就是 optimistic write 的本質
          2. 呼叫 Posts Repository 更新 app state,並透過網路通知 backend

          後端同步完成後,底層資料更新了,UI 也不再變動,因為一開始就主動改過了。原書從四個角度談:data layer 更新、錯誤處理、常見挑戰、資料流範例。

          📖 原書 本地 DB 當 queue

          更進一步:所有互動都先存本地,直到 backend 確認。本地 DB 依發生順序記錄互動;離線時累積的互動,恢復連線後 repository 在背景依序處理。文組翻譯:冰箱門上的便利貼,一張一張照順序寫,出門時再照順序去買。

          新的 UserInteraction model
          data class UserInteraction
            id: Long            // AUTO INCREMENT,維持順序
            postId: Long
            userId: Long
            action: UserInteractionAction
            status: UserInteractionStatus
            createdAt: String
            updatedAt: String   // 最後一次同步嘗試
            failureCount: Int   // 同步失敗次數
          
          enum class UserInteractionAction
            LIKED, UNLIKED, SHARED, BOOKMARKED
          enum class UserInteractionStatus
            PENDING, FAILED, CANCELED

          📖 原書 同一篇貼文上的多次互動全部都要同步,這些資料有分析價值;衝突用 last write wins。本地 DB 新增 UserInteractions table;同步成功後,repository 從這張表刪掉它,並更新 Posts table 對應的那一筆。

          原書 Step 4Data layer design update · Figure 7

          資料表變成 DAO:Posts DAO 和 User Interactions DAO

          這一步要解決的問題多了一張「待同步的便利貼」表之後,data layer 長什麼樣?

          📖 原書 Figure 7更新後的 data layer 設計(依原書內容重繪)

          📖 原書 在 data layer 設計裡,把資料庫的每張表畫成 Data Access Object(DAO)元件:

          • Posts DAO:Posts table,feed 與貼文本身
          • User Interactions DAO:新的 UserInteractions table,也就是待同步的 queue

          兩個 DAO 都接到同一個 Posts DB,由 Posts Local DataSource 使用;Posts Local DataSource 和 Posts Remote DataSource 一起餵給 Posts Repository,資料再往上到更高的層(圖上沒畫出來)。

          白話:DAO(Data Access Object)=一張資料表的專屬窗口,只有它讀寫那張表。

          文組翻譯:同一台冰箱有兩層:上層放食物(Posts),門上的磁鐵夾著便利貼(UserInteractions)。管家(Repository)兩邊都看得到。

          延伸基礎第 9 階 · backoff懂的人可以跳過

          1. API
          2. cursor
          3. requestId
          4. 流量預算
          5. 分層
          6. 本地快取
          7. 清冰箱
          8. 樂觀更新
          9. backoff
          10. sanitize
          11. main thread
          12. lazy loading
          13. 304

          菜市場電話不通:每秒狂打,還是越等越久再打?

          ① 先想像

          菜市場停電 30 秒。所有客人每秒打一次,老闆一恢復,全部電話同時湧進來,又把他淹掉。

          你猜猜看:停 30 秒,100 萬支手機每秒重打一次,這 30 秒共打幾通?

          ③ 這叫做 retry、exponential backoff

          retry:失敗了再試。exponential backoff:每失敗一次,等待時間加倍。

          ④ 跟這章的關係

          原書:同步失敗標 FAILED,越等越久地重試,到上限就放棄或通知使用者(第 38 頁)。後端那一側見 03 第 10 章第 18 頁。

          ② 動手玩:一支手機在 60 秒內打了幾通

          –停電期間,每支打了幾通–全部手機加起來–恢復後多久才接通

          原書 Step 4Error handling · Common challenges

          同步失敗了:exponential backoff,再不行就看它有多重要

          這一步要解決的問題同步失敗了怎麼辦?要多久重試一次、什麼時候放棄?

          📖 原書 ① 網路 request 失敗 → 狀態標成 FAILED ② 隔一段越來越長的時間重試 ③ 直到最大嘗試次數。到了上限呢?看重要性:不重要的(按讚)改成 CANCELED、rollback UI;重要的通知使用者,例如發文失敗就推播請他手動重試。

          📖 原書 樂觀寫入之後 backend 狀態變了?Conflict resolution:丟掉本地互動、嘗試合併,或通知使用者讓他決定;看用例與資料性質。

          📖 原書 常見挑戰與對策

          挑戰對策
          最大的挑戰:維持 client 與 backend 的資料一致把 backend 當 single source of truth;每次從 backend 收到資料,就更新本地 Posts DB 對齊
          互動可能被亂序套用每個互動記錄建立與最後修改時間;依序送給 backend
          Rollback 或衝突處理不清楚,UI 行為令人困惑關鍵情況通知使用者發生什麼、下一步怎麼做
          重試與衝突處理增加 backend 負擔Exponential backoff;必要時把互動 batch 起來送

          注意:本地 DB 是 client 內的 SSOT(給 UI 用),backend 是整個系統的 SSOT(衝突時以它為準)。原書兩種說法都有,指的層次不同。「亂序」這一格,Triton 在 027 有一模一樣的警告(第 54 頁)。

          原書 Step 4Optimistic write data flow · Figure 8

          按一下愛心,背後跑了 7 步

          這一步要解決的問題按一下愛心,背後的資料怎麼流?什麼時候才算真的存好?

          📖 原書 Figure 8樂觀寫入資料流(依原書內容重繪,步驟號碼照原圖)

          128

          UserInteractions table(本地 queue)

            • 1.1 更新 UI state(即時回饋)/1.2 通知 repository
            • 2 先存本地 → 3 和 backend 同步 → 4 同步成功
            • 5 刪掉那筆互動 → 6 更新 Post
            • 7 之後 DB 的更新不會讓 state holder 發出新的 UI state,因為 1.1 已經改過了

            🔍 原書 Industry insights Instagram 在 Direct 做了 Mutation Manager,管理樂觀寫入可能遇到的網路失敗與資料不一致。

            延伸基礎第 10 階 · sanitize懂的人可以跳過

            1. API
            2. cursor
            3. requestId
            4. 流量預算
            5. 分層
            6. 本地快取
            7. 清冰箱
            8. 樂觀更新
            9. backoff
            10. sanitize
            11. main thread
            12. lazy loading
            13. 304

            別人寫的貼文裡,藏了一段「指令」

            ① 先想像

            社區公佈欄讓大家貼海報。有人在海報裡夾一張「看到的人請把鑰匙放門口」。管理員貼之前要檢查,只留文字和圖片。

            你猜猜看:貼文裡藏了一段 <script>,app 不檢查就照著顯示,會怎樣?

            ③ 這叫做 HTML、sanitize

            HTML:用標籤排版的寫法,例如 <b>粗體</b>。sanitize:消毒,只留允許的標籤,其他拿掉。

            ④ 跟這章的關係

            原書選 HTML 寫 rich text,條件是一定要先 sanitize(第 41 頁有完整的消毒器可以玩)。

            ② 動手玩:五段貼文內容

            –漏進來的危險東西–保留下來的正常排版

            原書 Step 4Displaying rich post content · Table 4

            Rich text:自創標記語言,還是用 HTML/Markdown?

            這一步要解決的問題貼文要有標題、粗體、連結:內容要用什麼格式存?

            📖 原書 貼文內容存成單純的 String,但純文字顯示不符期待:要有連結、mention、文字樣式,本 app 還要標題、粗體、斜體。兩條路:自創 markup language,或用現成的 HTML/Markdown。

            📖 原書 自創成本高、要持續維護:Facebook 的 FBML 最後被淘汰,改用標準 HTML、JavaScript(主要是 React);X 仍用自己的 text library;Reddit 用特製版 Markdown。我們不值得自創。

            📖 原書 Table 4 貼文內容的編碼

            優點缺點
            HTML支援 feed 需要的豐富格式;能自訂元素(之後的文字 highlight、mention);跨平台呈現一致對不懂技術的人太複雜;要 sanitize 防 XSS;渲染吃資源,可能拖慢低階手機的捲動
            Markdown使用者較容易寫基本格式;可轉成 HTML 再渲染,處理彈性大格式有限,複雜版面可能不夠;仍有語法要學

            ✅ 原書:用 HTML。對策:制定 best practices,每個功能只用一種 HTML 寫法;backend 送來的內容與摘要都是 HTML 字串,先驗證與 sanitize。🛠️ Android:OWASP Java HTML Sanitizer、jsoup;iOS:HTMLKit、Purifier。

            動手試:把不安全的 HTML 消毒

            渲染結果

            被拿掉的東西

              只允許 h1–h3 p b strong i em a br ul ol li;a 只留 http(s) 的 href;其他標籤只留文字、事件屬性全部丟掉。這是白名單示意,不是完整的 sanitizer。

              原書 Step 4Rendering HTML · Table 5 · Figure 9

              WebView 直接畫,還是解析成原生元件?

              這一步要解決的問題HTML 貼文要怎麼畫到螢幕上,才不拖慢捲動?

              📖 原書 Table 5 在螢幕上渲染 HTML 貼文

              優點缺點
              WebView最少力氣畫出複雜格式,一個元件支援所有 HTML;外觀跨平台一致(和行動瀏覽器同引擎)記憶體較高,可能影響 feed 捲動;互動不夠原生,難和 feed 動畫無縫整合
              Native UI componentsfeed 捲動效能較好;符合平台設計語言,和其他手勢整合更順要自己寫 HTML → 原生 UI 的 parser;維護工作較多

              📖 原書 內容是較簡單的 HTML(格式文字、連結、圖片),解析成原生元件在效能與視覺品質間取得平衡;又能在建立內容時訂 best practices,所以選 parse HTML + native UI。

              白話:WebView=app 裡的一小塊瀏覽器;native UI=手機系統原生的元件;parser=把 HTML 拆成一個個元件的程式。

              ✅ 決定:HTML 編碼貼文內容;原生 UI 元件渲染。
              🔍 原書 Industry insights 2012 年 Facebook iOS app 從 HTML5 換成原生 iOS 程式碼優化效能;Reddit 改用 Server-Driven UI、剝掉回應裡不需要的資料,首頁 feed 延遲降 12%。

              📖 原書 Figure 9UI layer 設計更新(依原書內容重繪,虛線照原圖)

              📖 原書 新增 Post Content Renderer(靠 HTML Parser 用原生元件渲染),所有顯示貼文的畫面都依賴它:可讀、可測、跨畫面重用。Create Post 畫面用 Post Editor,輸入的 rich content 由 HTML Encoder 編成 String。

              到這裡你已經會了小結 3 / 4

              1. API
              2. cursor
              3. requestId
              4. 流量預算
              5. 分層
              6. 本地快取
              7. 清冰箱
              8. 樂觀更新
              9. backoff
              10. sanitize
              11. main thread
              12. lazy loading
              13. 304

              到這裡你已經會了:按讚和發文

              下一階要解決的問題

              功能都齊了。為什麼滑起來還是會卡?圖片什麼時候下載才不浪費流量?

              延伸基礎第 11 階 · main thread懂的人可以跳過

              1. API
              2. cursor
              3. requestId
              4. 流量預算
              5. 分層
              6. 本地快取
              7. 清冰箱
              8. 樂觀更新
              9. backoff
              10. sanitize
              11. main thread
              12. lazy loading
              13. 304

              每秒要端出 60 張畫面:一張最多只有 16 毫秒

              ① 先想像

              外場只有一位服務生,每秒要端出 60 張畫面。他若跑去洗碗,客人就看到畫面停住一下。

              你猜猜看:每秒要畫 60 張,每張最多能花幾毫秒?

              ③ 這叫做 main thread、jank

              main thread:唯一負責畫畫面、接手指的那位服務生。jank:趕不上,畫面卡一下。

              ④ 跟這章的關係

              原書排查卡頓:view 沒回收、main thread 做重活、版面太深、圖片太大(第 45 頁)。

              ② 動手玩:這一秒的 60 張畫面

              –準時的畫面–趕不上(卡一下)–感覺

              簡化模型:每張畫面的工作超過 16.7 毫秒就算趕不上。毫秒數是示意。

              原書 Step 4Janky news feed scrolling

              面試官問:「feed 滑起來卡卡的,可能是什麼原因?」

              這一步要解決的問題滑起來卡卡的:第一個該懷疑誰?

              📖 原書 這類假設情境題考的是效能優化與診斷能力。第一號嫌犯:view recycling 沒做好。回收的目的是重複使用已經看不到的 view,而不是每捲進一則就建一個新的:少建 view、少 layout,大幅提升效能、降低記憶體。新 view 進入可見區時,系統到 recycling pool 找識別碼相符的可重用 view,換上新資料;main thread 就有餘力處理互動和動畫。

              🛠️ Android:View 系統的 RecyclerView,或 Compose 的 LazyRow/LazyColumn;iOS:UITableView/UICollectionView,或 SwiftUI 的 List。

              📖 原書 非同步載入內容:圖片、附件在 data model 裡只是 URL,渲染時非同步載入,昂貴的工作不佔 main thread。

              📖 原書 其他渲染相關的低效率

              • Main thread blocking:重運算、同步網路、檔案 I/O 放 main thread 會凍結 UI → 全部移到背景執行緒
              • Complex layouts:太深的巢狀 view → 扁平化、減少階層、移除重疊
              • Inefficient state management:不必要的 re-render → state 更新做 debouncing、加 caching 與 memoization
              • Unoptimized images:大圖不處理就顯示 → 用高效的 media loading library;server 沒給優化版本就先縮成需要的尺寸

              動手試:滑一滑,數一數建了幾個 view

              0累計建立 view 次數0目前記憶體裡的 view0recycling pool 裡待用的順示意:這一秒的流暢度

              文組翻譯:自助餐的盤子。客人吃完的盤子洗一洗給下一位,餐廳只要幾十個盤子;每位客人都開一個新盤子,倉庫很快就爆了。

              延伸基礎第 12 階 · lazy loading懂的人可以跳過

              1. API
              2. cursor
              3. requestId
              4. 流量預算
              5. 分層
              6. 本地快取
              7. 清冰箱
              8. 樂觀更新
              9. backoff
              10. sanitize
              11. main thread
              12. lazy loading
              13. 304

              點了 30 道小菜:老闆會一次全端上桌嗎?

              ① 先想像

              一次全端上來,大半吃不完、冷掉。聰明的老闆先上你眼前那幾道,快吃完時再上下一道。

              你猜猜看:一頁 30 則、每張圖 300 KB,一打開就全下載,你只看了 5 則就關掉。浪費多少?

              ③ 這叫做 lazy loading、prefetch

              lazy loading:滑到了才下載。prefetch:預先載入,快滑到前先下載一兩張。

              ④ 跟這章的關係

              原書的 Media Loader 負責佔位圖和漸進載入;Reddit 在使用者滑太快時取消 prefetch(第 26、47 頁)。

              ② 動手玩:一頁 30 張圖

              –下載了–下載了卻沒看–捲進來要等的圖

              看過 下載了沒看 看的時候要等 沒下載 每張 300 KB,示意。

              原書 Step 4Dynamic image and video quality

              低階手機、3G 網路:圖片自動降一級

              這一步要解決的問題低階手機、爛網路:圖片和影片要不要自動降一級?

              📖 原書 捲動體驗直接受裝置效能影響:CPU、記憶體、GPU、網路、電量。對能力有限的裝置,依當下狀況動態調整圖片與影片品質,可以:減少載入時間、捲動維持穩定幀率、有效使用資源、在各種裝置與環境更有韌性。

              📖 原書 品質門檻

              LowMediumHigh
              Images480x320 或更低720x4801080x720 或更高
              Videos360p720p1080p 或更高

              Backend 要能依 client 的 request 給同一媒體的不同版本:預先處理好多個品質存起來,或依需求動態產生。

              🛠️ 🔍 原書 Facebook 的開源框架 Litho 把大量 UI 工作移出 main thread:用了 Litho 的影片元件後 News Feed 捲動快達 20%,部分列表子 view 達 42%。Pinterest 優化 ABR 串流管線,影片啟動延遲降約 36%。Reddit 在使用者滑太快時取消影片 prefetch,把非必要工作延後。

              白話:幀率(fps)=每秒幾張畫面;ABR=影片依網速自動換畫質;prefetch=預先下載(第 46 頁)。

              High選到的品質–這張大小(示意)–捲進畫面後等多久才清楚0 KB累計流量

              先出現灰色佔位框,再來模糊的縮圖,最後才是清楚的圖:這就是 Media Loader 的佔位與漸進載入。大小與網速是示意值,不是原書數字。

              原書 Step 5Wrap-up

              原書的收尾:還有時間,可以再談這七個延伸

              這一步要解決的問題面試快結束了:還有時間的話,可以往哪裡延伸?

              📖 原書 本章做了什麼

              • client 發起的 request 用 HTTP + REST,網路資料用 JSON
              • 依 REST 原則設計 backend endpoints 支撐核心功能
              • 具離線支援的 client 架構,深入:選本地儲存、樂觀寫入與無縫離線互動、渲染 rich post content、解決 feed 捲動卡頓

              📖 原書 延伸題

              1. 留言功能:對貼文留言、回覆別人的留言
              2. 推播通知與即時更新:通知貼文的互動、計數與新留言即時更新 🗣️ 第 56 頁
              3. 搜尋:線上與離線貼文都能搜;本地 DB 可研究 Full-Text Search(FTS)
              4. 貼文編輯:已同步到 client 的貼文被改了怎麼辦
              5. 排程貼文:未來某時間才發佈(Android、iOS 的背景任務)
              6. 智慧 pre-fetching:裝置在理想條件時才下載貼文
              7. 多語言:處理各種語言的貼文

              原書引用的參考資料(25 筆)

              Meta Graph API、Reddit API、X API、UUID、Snowflake ID、Facebook 支援全球事件的 production engineering、iOS News Feed 快近 50%、Instagram background prefetching、Reddit 的 ExoPlayer 影片播放、Instagram Direct 樂觀寫入、FBML 淘汰、twitter-text、Reddit Markdown、Reddit Server-Driven UI、Litho、Pinterest ABR(兩篇)、留言區、Push technology、Full-text search、Android/iOS 背景任務、Prefetching、Android/iOS 多語言。

              Triton 觀點先說清楚他有講、沒講什麼

              Triton 只寫過後端:這章他能評的是 API 那一半

              原書段落Triton 的資料本簡報
              Pagination(cursor)062 lastTs/nextPageTs、087 ?ts=、009 筆記第 50 頁
              Table 1 的 HTTP caching027/028 Conditional GET、304、146第 52 頁
              FeedApiResponse 嵌入 author150 N+1、088 MGET、072 預先計算、058 筆記第 53 頁
              requestId、201、stateless、亂序、versioning、GraphQL027、167、016第 54 頁
              CDN、推播(延伸題)137 主文、166、146第 56 頁
              Feed 格式、新鮮度076 HYPEBEAST、088第 57 頁
              本地 DB、eviction、SSOT、optimistic UI、rich text 渲染、view recycling、圖片品質無照原書講,不硬套

              怎麼讀接下來幾頁

              🗣️ Triton 本人說 是 materials/core 裡 Triton 講義或文章的原文,附檔名。🔭 依 Triton 原則推論 是把他的原則套到這一章,不是他說過的話。📝 上課筆記 是學員(Roy)的筆記;💬 討論串回覆 是作者未標示的留言,不當成 Triton。

              整體態度

              原書選 REST + JSON、cursor 分頁、ID 由 backend 產生、請求帶 requestId,這些 Triton 的 RESTful 講義(027)幾乎都同意。他能補的是:cursor 到底該長什麼樣、為什麼這樣才能 cache、後端在這支 API 背後要避開哪些坑。

              materials/core 裡沒有任何 client 端(offline-first、本地 DB、電池、UI 架構、圖片載入)的 Triton 資料,所以這些頁只放原書標籤。

              Triton 補充原書說用 cursor,沒說 cursor 是什麼

              ✅ 同意 cursor 用時間戳:同一頁永遠長一樣,才能 cache

              原書只說「用 cursor」。如果書籤是「第幾頁」,關 app 期間來了 5 篇新文,手機快取裡的第 1–3 頁還能直接用嗎?

              「GET /v1/chatrooms/<roomId>/messages – Optional parameter: lastTs – Chronological descending order – 支持 pagination ,返回大約上限 50 個訊息 除了 array of message ,還會有 nextPageTs」🗣️ Triton 本人說 062-im-system design.pdf.md · 訊息相關 endpoint

              「若用 page id 會隨著時間回傳內容不同,因為下一秒又發新的 msg 這樣很難做 cache, cache 就會 invalidate」「lastTs ⇒ lastMs (毫秒」📝 上課筆記 009 · Roy 的 MVP IM 課堂筆記,非本人原文

              「如果沒有 snapshotting,剛好第十名的物品變第十一,然後你拿 Page 2的資料 – 你就會看到重覆的物品 RESTful endpoint: – GET /v1/leaderboard?ts=1561042015」🗣️ 087-redis-2019.pdf.md · 案例 2:data snapshotting

              🔭 推論 原書的 GET /v1/feed?after=<some-value> 照 062 具體化:after 就是上一頁最後一則的毫秒 createdAt,PaginationMetadata 裡放 nextPageTs。「比這個時間更舊的 30 則」不會因為有人發新文而改變,所以只有第一頁(062 的 -now)需要重抓。注意 062 是聊天室,所有人看同一份歷史;feed 是每人一份,可以共用的是同一個人的 client 快取與 server 快取。

              動手試:關掉 app、有新貼文、再打開滑三頁

              page id/offset

                lastTs

                  –offset:要重抓的頁–lastTs:要重抓的頁

                  每頁 30 則。✓ 表示快取裡那一頁的內容仍然正確,可以直接用;✗ 表示內容已經位移,必須重抓。

                  延伸基礎第 13 階 · 304懂的人可以跳過

                  1. API
                  2. cursor
                  3. requestId
                  4. 流量預算
                  5. 分層
                  6. 本地快取
                  7. 清冰箱
                  8. 樂觀更新
                  9. backoff
                  10. sanitize
                  11. main thread
                  12. lazy loading
                  13. 304

                  「上週那份價目表,有改嗎?」沒改就不用重寄

                  ① 先想像

                  你手上有菜市場上週的價目表。與其叫老闆整份重寄,不如問一句「有改嗎?」沒改,老闆回「沒改」就好。

                  你猜猜看:同一篇打開 10 次,都沒改。每次整份拿(2.4 KB)和先問再拿(「沒改」約 0.2 KB),各下載多少?

                  ③ 這叫做 conditional GET、304

                  conditional GET:帶著「我手上的版本」去問。304 Not Modified:沒改,不用重寄。

                  ④ 跟這章的關係

                  原書 Table 1 只寫「可以用 HTTP caching」;Triton 的講義寫了具體做法(第 52 頁)。status code 見 03 第 4 章第 7 頁。

                  ② 動手玩:同一張價目表

                  0打開幾次0 KB總共下載

                  Triton 補充Table 1 的「HTTP caching」具體怎麼做

                  手機裡已經有一份了:先問「有變嗎?」,沒變就回 304

                  原書 Table 1 只寫「可以用 HTTP caching」。第二次打開同一篇沒改過的貼文,如果還是整份重下載,會怎樣?

                  「304(Not Modified) – 如果客戶端已經有了某一物件的副本,但是不知道這 物件是否最新版本 – 客戶端會發出 Conditional-GET ,在 HTTP header 中加入 If-Modified-Since: <某時間> – 如果客戶端版本是最新的,便回答 304 。否則便 200」🗣️ Triton 本人說 027-RESTful API Design-tw-2.1.pdf.md(028 同)· 常用 HTTP 回答碼:3xx

                  「客戶端可以建立本地快取 在下次請求時,客戶會把本地快取版本告訴伺服器。如果伺服器發現資源沒有改動,反回 HTTP 304 可以省下伺服器 CPU 資源和網路流量(=省錢) 不常變動的物件適合設定為可快取」🗣️ 027 · 能夠利用快取機制增進性能

                  「設定好CDN(像是Fastly / cloudflare),設定好你的HTTP header的cache相關的。」🗣️ 146-在C10K以下的世界….md · 第 1 點

                  🔭 推論 原書的本地 DB 就是 027 說的「本地快取」。打開快取過的貼文詳情時,把 DB 裡那份的版本帶上去問;沒變就 304,body 是空的。這正好對上原書非功能需求的 Data efficiency。

                  
                        
                  0request 次數0 B實際下載0 B每次都 200 的話

                  027 講的是 If-Modified-Since;ETag/If-None-Match 是 HTTP 標準的另一種寫法,不是 Triton 講義的內容,放在這裡對照。

                  Triton 補充GET /v1/feed 背後,後端要做什麼

                  一頁 30 則、每則嵌一個 author:別查 31 次

                  原書每則 PostPreview 都嵌了 author。後端如果一則一則去查作者:一頁 30 則、每次 DB 來回 5ms,光來回要多久?

                  「例子: facebook newsfeed – 每人的 newsfeed都是預先計算,而不是即時地查詢的 – 用簡單的 Range Scan on PK 便可以 今天 Disk Volume不值錢, Disk IO才值錢」🗣️ Triton 本人說 072-lesson3.pdf.md · Data fan-out

                  「即使每個select只吃掉5ms(這是算很不錯的數字了),單單因為這些overhead便浪費掉10 * 5ms = 50ms!」方案1:「把要拿的userId先集中到一個array,然後用單一的query去拿全部的record」方案2:inner join users。「以上例子,其實只是backend developer的入門級知識。」🗣️ 150-在一般的留言版….md

                  「如果有 1000筆ActivityHistory,先掃瞄一次拿出全部的UserID – 以 redis MGET,一次過拿回 1000個User.displayName」🗣️ 088-redis-intro.pdf.md · Anti pattern: data size-dependent IO operations

                  📝 上課筆記「FB 如果用 Mysql post PK 會用哪個 Triton: post : postID (uuid) PK (postID + create_ts) 一個 Seq.Scan Io 依次拿出來 在動態牆」058 · Roy 的筆記:方向是「feed 依 PK 物理相鄰、一次 seq scan」,但筆記裡的欄位順序和 062「一定是 (chatroomId, createTs)」的原則對不上,存疑。

                  動手算:原書的 limit=30

                  31DB 來回次數155 ms光是來回的 overhead
                  
                        

                  🔭 推論 原書的 PostPreview 把 AuthorPreview 嵌在每一則裡,讓 client 一個 request 就拿齊,這對手機是好設計;代價是後端要負責「一次補齊」。fanout、feed cache、hot key 的細節見 03 SDI 第 11 章簡報;一筆一筆補資料的問題另見第 20 頁。

                  Triton 補充RESTful 講義對原書 API 的逐條對照(1/2)

                  requestId、201、stateless、亂序:027 早就寫過

                  原書 Table 1 說 REST 的優點是「server stateless」。那後面的資料庫、快取,也都不能存狀態嗎?

                  同意 重送要認得出來

                  「在客戶端,任何未成功收到傳回訊息的 API ,只 需要重新呼叫。 伺服器端需要懂得處理重覆 API request 在建立新物件時,把客戶端時間也放到 API request 中,讓伺服器能分辦是否收到重覆的 HTTP POST」🗣️ 027 · Idempotence(重新呼叫)

                  原書用 client 產生的 requestId,Triton 用 client 時間,目的相同:辨認重覆的 POST。兩者都不拿來當 created_at,和原書「時間戳由 backend 產生」不衝突。

                  小差異 201 要不要帶 ID

                  原書:201、body 不帶資料。027:POST「一般會把資源的 ID 返回給用戶」027 · HTTP method-POST。🔭 對 offline-first 的 app 尤其有用:本地 DB 先存了一筆用 requestId 標記的貼文,回應帶 postId 就能直接對上,不用再拉一次 feed。

                  更精確 「Servers are stateless」

                  「server side 需要 stateless – 正解 1 : HTTP 只要求 protocol 本身是 stateless ,從未要求伺服器是 Stateless – 正解 2 : RESTful 只要求 Application Server 是 stateless , Server Side 其他部份可以 stateful」🗣️ 027 · 先談 RESTful謬誤

                  Triton 補充RESTful 講義對原書 API 的逐條對照(2/2)

                  依序送、重送兩次也沒事:027 的另外兩條

                  原書說互動要「依序」送。手機先送「按讚」、再送「取消讚」,server 一定照這個順序收到嗎?

                  同意 為什麼要依序送互動

                  「除非使用同一個 TCP/IP連線,否則當客戶端先發出 < 指 令1 > ,然後再發出 < 指令2 > ,在次序錯亂的情況下, 伺服器有可能先收到 < 指令2 >」🗣️ 027 · 淺談網路的不穩定性

                  這正是原書 Common challenges 的「互動可能被亂序套用」,原書的對策(依序送、帶時間戳)和 027 一致。

                  動手試:哪些互動重送兩次也沒事?

                  「這是 idempotent 的 PATCH – SET Age = 31 這不是 idempotent 的 PATCH – SET Age = Age + 1」🗣️ 027 · HTTP method-PATCH(續)

                  🔭 點一個,看它重送兩次的結果。

                  🗣️「CDN正常應該只去cache成功的request的」→ 跟好 status code,CDN 只看 header 就好;「你去看看facebook花多少年才能deprecate舊的endpoint,就明白為何API的tech debt是最難還清的了」167,呼應原書的 /v1/。🗣️「GraphQL和RESTful本身不是mutual exclusive的」016 第一段。

                  Triton 補充原書排除的推播、原書加的 CDN

                  一千萬人同一秒點開推播:CDN 擋得住嗎?

                  原書說 CDN 能扛「流量高峰」。一千萬人同一秒收到推播、1% 點開,CDN 上還沒有這篇,會怎樣?

                  「如果你有10M active user 你想過發promotional notification給這10M user,讓用戶同秒收到 就只1% 點開來也好,流量足夠穿過CDN讓你的backend支持不了給blank page了」🗣️ Triton 本人說 137-喵談 push notification.md · 主文

                  💬 討論串回覆,作者未標示「CDN也要時間warm-up的 你同秒太多相同的request,就是cache-miss讓你server 來面對」以及「先random抽一小部份人來push notification…warm-up後再push剩下的」:同一串的留言,沒標作者,不算 Triton 的話。

                  「Write不能用CDN,Read可以。」🗣️ 166-有人問一個系統的server cost….md

                  「別凡事沒腦問Server拿資料 … 壞主意:每5min問Server拿「過去72小時價格」 好主意:page load時拿「過去72小時價格」,然後以websocket接收「最新報價」去append到「過去72小時價格」後面。」🗣️ 146 · 第 2 點

                  –這一秒點開–打到後端的 req/s–後端

                  🔭 推論 點開推播後 app 要兩樣東西:貼文詳情與圖片(大家都一樣,Read,可以走 CDN)、個人 feed(每人不同,CDN 擋不了,一定打到後端)。原書的 SSOT 讓 app 先秀本地 DB 的舊 feed,背景再補,這就是 146 說的「別凡事沒腦問 Server」。數字是示意。

                  Triton 補充Triton 做過的 feed:HYPEBEAST suggestion feed

                  推薦 feed 和最新 feed 長一模一樣:client 只寫一份程式

                  後端加了一個「推薦 feed」。如果它回傳的格式和最新 feed 不一樣,手機那端要怎麼辦?

                  「Latest Feed is provided by Wordpress Suggestion Feed should be 100% format compatible with Latest Feed – Minimize client side development – Keep single piece of code – future-proof」🗣️ Triton 本人說 076-mini-bigdata.pdf.md · Integration with Wordpress(HYPEBEAST > 3M MAU)

                  「All data is cached – The user profile, the article content, the article score...... – Performance is MUCH more important then data freshness – "softcache" library to avoid disaster of cache miss in hot data」🗣️ 076 · Suggestion Feed Performance

                  「用戶頁面顯示的,是「某時間點的 snapshot」 而不是「即時資訊」 所以,你的 cache需要維持的,很有可能不是「最新資訊」」🗣️ 088 · 反思 caching(1)

                  同一個 renderer

                  🔭 推論 套到本章:原書所有清單都用同一個 PostPreview 與同一個 Post Content Renderer,後端換排序或推薦邏輯,client 不用改(Reddit 的 Server-Driven UI 是同一個方向)。「效能比新鮮度重要」則和原書的離線設計同一個精神:先秀冰箱裡 15 天內的舊貼文,比轉圈等最新的好。但這是 Triton 談後端 cache 的話,不是談 client。

                  到這裡你已經會了小結 4 / 4

                  1. API
                  2. cursor
                  3. requestId
                  4. 流量預算
                  5. 分層
                  6. 本地快取
                  7. 清冰箱
                  8. 樂觀更新
                  9. backoff
                  10. sanitize
                  11. main thread
                  12. lazy loading
                  13. 304

                  到這裡你已經會了:滑得順、省流量

                  13 階全部走完了

                  下一頁用一句話收尾;再下一頁是名詞小卡,給大家課後複習。

                  一句話記住

                  畫面只看冰箱,網路只負責補貨;
                  補貨的單子用時間戳當書籤,沒變就回 304。

                  原書的 client 骨架

                  • HTTP + REST + JSON;PostPreview/PostDetail 兩層
                  • Repository + Local/Remote data source;本地 relational DB 是 SSOT
                  • LRU + TTL 15 天 + 最低 50 則;登出清空
                  • 樂觀寫入、UserInteractions queue、exponential backoff
                  • HTML + sanitize + 原生元件渲染;view recycling;圖片分級

                  Triton 同意並補具體做法

                  • cursor = 毫秒 lastTs,回 nextPageTs(062、009 筆記)
                  • Conditional GET、304,客戶端本地快取(027/028)
                  • 重送要能去重、依序送、URL 是名詞(027)
                  • 嵌入的 author 一次補齊,別 N+1(150、088);feed 預先計算(072)

                  原書沒談、Triton 會追問

                  • 同秒推播 1% 點開就穿過 CDN(137 主文)
                  • 個人 feed 是 CDN 擋不了的 Read(🔭 166)
                  • 「server stateless」只指 application server(027)
                  • 推薦 feed 要和最新 feed 同格式(076)

                  本章名詞小卡課後複習用 · 每個名詞一句白話

                  今天出現的名詞,一句話講完

                  client、backend手機那一端/菜市場那一端的 server
                  request、API送出去的一張單子/菜市場公開的訂貨窗口
                  HTTP、REST網路上約好的一問一答格式/用網址當名詞的 API 設計風格
                  JSON單子的寫法:"欄位": 值
                  GET、POST拿東西/送東西過去
                  200、201、304給你/建好了/沒改,不用重寄
                  pagination、cursor一次一批/記住看到哪的書籤
                  offset記「從第幾則開始」;有新文就位移
                  requestId、idempotency單子上的編號/送幾次都跟一次一樣
                  data efficiency、thumbnail少花流量/清單上的縮圖
                  PostPreview、PostDetail清單用的輕量版/點進去的完整版
                  MAU每月有打開 app 的人數

                  給工程師的重點出處與原書對照

                  引述來源(materials/core)與原書段落

                  Triton 本人的講義/文章

                  • 062-im-system design.pdf.md — 訊息 endpoint:lastTs、descending、約 50 則、nextPageTs;Caching with pagination 與 cache key 設計
                  • 087-redis-2019.pdf.md — 案例 2 data snapshotting:排名榜翻頁看到重覆、GET /v1/leaderboard?ts=1561042015
                  • 027/028-RESTful API Design-tw-2.1/2.2.pdf.md — 304 與 Conditional-GET、「客戶端可以建立本地快取」、Idempotence 帶客戶端時間、POST 回傳 ID、RESTful 謬誤(stateless)、網路亂序、PATCH idempotency
                  • 150-在一般的留言版….md — 留言作者 N+1、5ms、IN + HashMap、INNER JOIN
                  • 088-redis-intro.pdf.md — data size-dependent IO、MGET;snapshot 而非即時資訊
                  • 072-lesson3.pdf.md — Data fan-out:facebook newsfeed 預先計算、Range Scan on PK
                  • 076-mini-bigdata.pdf.md — HYPEBEAST suggestion feed:與 Latest Feed 100% 同格式、「Performance is MUCH more important then data freshness」
                  • 137-喵談 push notification.md — 只有主文:10M 同秒推播、1% 點開穿過 CDN。暖 CDN、分批推播是未標作者的回覆(💬)
                  • 166 Write 不能用 CDN · 146 設定好 CDN 與 cache header、別凡事問 server · 167 status code 與 CDN、FB deprecate endpoint · 016 第一段 GraphQL 與 RESTful 不互斥

                  上課筆記(非本人原文):009(Roy 的 MVP IM 筆記:page id 難 cache、lastTs ⇒ lastMs)、058(Roy 的 columnar storage 筆記:FB post PK,欄位順序存疑)。PDF 轉出的「⽤」「⼀」等部首字元,引用時寫成一般的「用」「一」。

                  原書對照

                  Mobile System Design Interview,Chapter 3 News feed app。開頭定義與 Figure 1(第 4 頁);Step 1 對話(5)、Requirements(6)、UI sketch 與 Figure 2(7);Step 2 Communication protocol、Figure 3、Table 1(9)、Table 2 與 GraphQL(10)、Feed retrieval 與 data models(11)、Pagination(13)、Post creation(15)、Post details(17)、User interactions(18)、ID and timestamp generation(19);Step 3 Figure 4(22)、External components 與 Client architecture(23)、Data layer(24)、UI layer(25–26)、Data flow 與 Figure 6(28);Step 4 Local storage 與 Table 3(29)、Eviction(31)、Offline UX(32)、Optimistic writes(35)、Figure 7(36)、Error handling 與 Common challenges(38)、Figure 8(39)、Rich content 與 Table 4(41)、Rendering、Table 5、Figure 9(42)、Janky scrolling(45)、Dynamic quality(47);Step 5 Wrap-up 與 Resources(48)。原書 9 張圖都依圖說與 alt 描述重繪(Figure 1、2 是 app 線框圖,畫成線框),不是原圖;5 張表與所有 data model 照原書列出。

                  循序漸進(文組版)的頁面:學習地圖(第 3 頁);延伸基礎 13 階:API(8)、cursor(12)、requestId(14)、流量預算(16)、分層(21)、本地快取(27)、清冰箱(30)、樂觀更新(34)、backoff(37)、sanitize(40)、main thread(44)、lazy loading(46)、304(51);小結(20、33、43、58);名詞小卡(60)。後端概念連到 03 SDI 第 1、4、10、11、26 章的延伸基礎頁。冰箱、菜市場、5 GB、每秒滑 6 則等是示意,不是原書數字。

                  一個可以直接問自己的問題

                  你的 app 第二次打開同一篇貼文,下載了幾個 byte?如果答案跟第一次一樣,027 說的本地快取和 304 就還沒做。

                  ← → 翻頁 · S 講者備註 · D 深/淺色
                  1 / 1目錄