From 0e4df4b50536a1b300d4618ea13390869aeb4ba7 Mon Sep 17 00:00:00 2001
From: Jiyong Park <55639800+jiyongp@users.noreply.github.com>
Date: Mon, 28 Aug 2023 23:53:27 +0900
Subject: [PATCH] ko: Update translation (#1116)

---
 po/ko.po | 16713 ++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 10815 insertions(+), 5898 deletions(-)

diff --git a/po/ko.po b/po/ko.po
index b6533650..4ead7487 100644
--- a/po/ko.po
+++ b/po/ko.po
@@ -5,28 +5,25 @@ msgstr ""
 "PO-Revision-Date: \n"
 "Last-Translator: \n"
 "Language-Team: \n"
+"Language: ko\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Language: ko\n"
 "Plural-Forms: nplurals=1; plural=0;\n"
+"X-Generator: Poedit 3.3.2\n"
 
-#: src/SUMMARY.md:3 src/welcome.md:1
+#: src/SUMMARY.md:4 src/index.md:1
 msgid "Welcome to Comprehensive Rust 🦀"
 msgstr "Comprehensive Rust에 오신 것을 환영합니다 🦀"
 
-#: src/SUMMARY.md:4 src/running-the-course.md:1
+#: src/SUMMARY.md:5 src/running-the-course.md:1
 msgid "Running the Course"
 msgstr "강의 진행"
 
-#: src/SUMMARY.md:5 src/running-the-course/course-structure.md:1
+#: src/SUMMARY.md:6 src/running-the-course/course-structure.md:1
 msgid "Course Structure"
 msgstr "강의 구성"
 
-#: src/SUMMARY.md:6 src/running-the-course/day-4.md:1
-msgid "Day 4"
-msgstr "4일차"
-
 #: src/SUMMARY.md:7 src/running-the-course/keyboard-shortcuts.md:1
 msgid "Keyboard Shortcuts"
 msgstr "단축키"
@@ -55,7 +52,8 @@ msgstr "카고(Cargo) 수행하기"
 msgid "Day 1: Morning"
 msgstr "1일차 오전"
 
-#: src/SUMMARY.md:19 src/SUMMARY.md:75 src/SUMMARY.md:128 src/SUMMARY.md:184
+#: src/SUMMARY.md:19 src/SUMMARY.md:76 src/SUMMARY.md:130 src/SUMMARY.md:187
+#: src/SUMMARY.md:213 src/SUMMARY.md:263
 msgid "Welcome"
 msgstr "개요"
 
@@ -119,713 +117,949 @@ msgstr "String과 str"
 msgid "Functions"
 msgstr "함수"
 
-#: src/SUMMARY.md:35 src/SUMMARY.md:82 src/basic-syntax/methods.md:1
+#: src/SUMMARY.md:35 src/basic-syntax/rustdoc.md:1
+msgid "Rustdoc"
+msgstr "Rustdoc"
+
+#: src/SUMMARY.md:36 src/SUMMARY.md:83 src/basic-syntax/methods.md:1
 #: src/methods.md:1
 msgid "Methods"
 msgstr "메서드"
 
-#: src/SUMMARY.md:36
+#: src/SUMMARY.md:37
 msgid "Overloading"
 msgstr "오버로딩"
 
-#: src/SUMMARY.md:37 src/SUMMARY.md:66 src/SUMMARY.md:90 src/SUMMARY.md:119
-#: src/SUMMARY.md:148 src/SUMMARY.md:176 src/SUMMARY.md:199 src/SUMMARY.md:226
-#: src/exercises/day-4/morning.md:1 src/exercises/day-4/android.md:1
+#: src/SUMMARY.md:38 src/SUMMARY.md:67 src/SUMMARY.md:91 src/SUMMARY.md:121
+#: src/SUMMARY.md:150 src/SUMMARY.md:179 src/SUMMARY.md:206 src/SUMMARY.md:227
+#: src/SUMMARY.md:255 src/SUMMARY.md:277 src/SUMMARY.md:298
+#: src/exercises/android/morning.md:1 src/exercises/bare-metal/morning.md:1
+#: src/exercises/bare-metal/afternoon.md:1
+#: src/exercises/concurrency/morning.md:1
+#: src/exercises/concurrency/afternoon.md:1
 msgid "Exercises"
 msgstr "연습문제"
 
-#: src/SUMMARY.md:38 src/exercises/day-1/implicit-conversions.md:1
+#: src/SUMMARY.md:39 src/exercises/day-1/implicit-conversions.md:1
 msgid "Implicit Conversions"
 msgstr "묵시적 형변환"
 
-#: src/SUMMARY.md:39
+#: src/SUMMARY.md:40
 msgid "Arrays and for Loops"
 msgstr "배열과 for 반복문"
 
-#: src/SUMMARY.md:41
+#: src/SUMMARY.md:42
 msgid "Day 1: Afternoon"
 msgstr "1일차 오후"
 
-#: src/SUMMARY.md:43 src/basic-syntax/variables.md:1
+#: src/SUMMARY.md:44 src/basic-syntax/variables.md:1
 msgid "Variables"
 msgstr "변수"
 
-#: src/SUMMARY.md:44 src/basic-syntax/type-inference.md:1
+#: src/SUMMARY.md:45 src/basic-syntax/type-inference.md:1
 msgid "Type Inference"
 msgstr "타입 추론"
 
-#: src/SUMMARY.md:45
+#: src/SUMMARY.md:46
 msgid "static & const"
 msgstr "정적변수(static)와 상수(const)"
 
-#: src/SUMMARY.md:46 src/basic-syntax/scopes-shadowing.md:1
+#: src/SUMMARY.md:47 src/basic-syntax/scopes-shadowing.md:1
 msgid "Scopes and Shadowing"
 msgstr "범위(Scopes)와 쉐도잉(Shadowing)"
 
-#: src/SUMMARY.md:47 src/memory-management.md:1
+#: src/SUMMARY.md:48 src/memory-management.md:1
 msgid "Memory Management"
 msgstr "메모리 관리"
 
-#: src/SUMMARY.md:48
+#: src/SUMMARY.md:49
 msgid "Stack vs Heap"
 msgstr "스택(Stack)과 힙(Heap)"
 
-#: src/SUMMARY.md:49 src/memory-management/stack.md:1
+#: src/SUMMARY.md:50
 msgid "Stack Memory"
 msgstr "스택 메모리"
 
-#: src/SUMMARY.md:50 src/memory-management/manual.md:1
+#: src/SUMMARY.md:51 src/memory-management/manual.md:1
 msgid "Manual Memory Management"
 msgstr "수동 메모리 관리"
 
-#: src/SUMMARY.md:51 src/memory-management/scope-based.md:1
+#: src/SUMMARY.md:52 src/memory-management/scope-based.md:1
 msgid "Scope-Based Memory Management"
 msgstr "범위기반 메모리 관리"
 
-#: src/SUMMARY.md:52
+#: src/SUMMARY.md:53
 msgid "Garbage Collection"
 msgstr "가비지 컬렉션"
 
-#: src/SUMMARY.md:53
+#: src/SUMMARY.md:54
 msgid "Rust Memory Management"
 msgstr "러스트의 메모리 관리"
 
-#: src/SUMMARY.md:54 src/memory-management/comparison.md:1
+#: src/SUMMARY.md:55 src/memory-management/comparison.md:1
 msgid "Comparison"
 msgstr "비교"
 
-#: src/SUMMARY.md:55 src/ownership.md:1
+#: src/SUMMARY.md:56 src/ownership.md:1
 msgid "Ownership"
 msgstr "소유권"
 
-#: src/SUMMARY.md:56 src/ownership/move-semantics.md:1
+#: src/SUMMARY.md:57 src/ownership/move-semantics.md:1
 msgid "Move Semantics"
 msgstr "Move 문법"
 
-#: src/SUMMARY.md:57 src/ownership/moved-strings-rust.md:1
+#: src/SUMMARY.md:58 src/ownership/moved-strings-rust.md:1
 msgid "Moved Strings in Rust"
 msgstr "러스트에서의 문자열 이동"
 
-#: src/SUMMARY.md:58 src/ownership/double-free-modern-cpp.md:1
+#: src/SUMMARY.md:59
 msgid "Double Frees in Modern C++"
 msgstr "Modern C++에서 이중해제 문제"
 
-#: src/SUMMARY.md:59 src/ownership/moves-function-calls.md:1
+#: src/SUMMARY.md:60 src/ownership/moves-function-calls.md:1
 msgid "Moves in Function Calls"
 msgstr "함수 호출에서의 이동(Move)"
 
-#: src/SUMMARY.md:60 src/ownership/copy-clone.md:1
+#: src/SUMMARY.md:61 src/ownership/copy-clone.md:1
 msgid "Copying and Cloning"
 msgstr "복사와 복제"
 
-#: src/SUMMARY.md:61 src/ownership/borrowing.md:1
+#: src/SUMMARY.md:62 src/ownership/borrowing.md:1
 msgid "Borrowing"
 msgstr "빌림"
 
-#: src/SUMMARY.md:62 src/ownership/shared-unique-borrows.md:1
+#: src/SUMMARY.md:63 src/ownership/shared-unique-borrows.md:1
 msgid "Shared and Unique Borrows"
 msgstr "공유와 고유 빌림"
 
-#: src/SUMMARY.md:63 src/ownership/lifetimes.md:1
+#: src/SUMMARY.md:64 src/ownership/lifetimes.md:1
 msgid "Lifetimes"
 msgstr "수명"
 
-#: src/SUMMARY.md:64 src/ownership/lifetimes-function-calls.md:1
+#: src/SUMMARY.md:65 src/ownership/lifetimes-function-calls.md:1
 msgid "Lifetimes in Function Calls"
 msgstr "함수 호출에서의 수명"
 
-#: src/SUMMARY.md:65 src/ownership/lifetimes-data-structures.md:1
+#: src/SUMMARY.md:66 src/ownership/lifetimes-data-structures.md:1
 msgid "Lifetimes in Data Structures"
 msgstr "구조체에서의 수명"
 
-#: src/SUMMARY.md:67 src/exercises/day-1/book-library.md:1
-#: src/exercises/day-1/solutions-afternoon.md:3
-msgid "Designing a Library"
-msgstr "도서관 설계"
+#: src/SUMMARY.md:68 src/exercises/day-1/book-library.md:1
+msgid "Storing Books"
+msgstr "책 저장하기"
 
-#: src/SUMMARY.md:68 src/exercises/day-1/iterators-and-ownership.md:1
+#: src/SUMMARY.md:69 src/exercises/day-1/iterators-and-ownership.md:1
 msgid "Iterators and Ownership"
 msgstr "반복자와 소유권"
 
-#: src/SUMMARY.md:71
+#: src/SUMMARY.md:72
 msgid "Day 2: Morning"
 msgstr "2일차 오전"
 
-#: src/SUMMARY.md:76 src/structs.md:1
+#: src/SUMMARY.md:77 src/structs.md:1
 msgid "Structs"
 msgstr "구조체"
 
-#: src/SUMMARY.md:77 src/structs/tuple-structs.md:1
+#: src/SUMMARY.md:78 src/structs/tuple-structs.md:1
 msgid "Tuple Structs"
 msgstr "튜플"
 
-#: src/SUMMARY.md:78 src/structs/field-shorthand.md:1
+#: src/SUMMARY.md:79 src/structs/field-shorthand.md:1
 msgid "Field Shorthand Syntax"
 msgstr "필드 할당 단축 문법"
 
-#: src/SUMMARY.md:79 src/enums.md:1
+#: src/SUMMARY.md:80 src/enums.md:1
 msgid "Enums"
 msgstr "열거형"
 
-#: src/SUMMARY.md:80 src/enums/variant-payloads.md:1
+#: src/SUMMARY.md:81 src/enums/variant-payloads.md:1
 msgid "Variant Payloads"
 msgstr "데이터를 포함하는 열거형(Variant Payloads)"
 
-#: src/SUMMARY.md:81 src/enums/sizes.md:1
+#: src/SUMMARY.md:82 src/enums/sizes.md:1
 msgid "Enum Sizes"
 msgstr "열거형의 크기"
 
-#: src/SUMMARY.md:83 src/methods/receiver.md:1
+#: src/SUMMARY.md:84 src/methods/receiver.md:1
 msgid "Method Receiver"
 msgstr "메서드 리시버(Receiver)"
 
-#: src/SUMMARY.md:84 src/SUMMARY.md:159 src/SUMMARY.md:194
+#: src/SUMMARY.md:85 src/SUMMARY.md:161 src/SUMMARY.md:276
 #: src/methods/example.md:1 src/concurrency/shared_state/example.md:1
 msgid "Example"
 msgstr "예제"
 
-#: src/SUMMARY.md:85 src/pattern-matching.md:1
+#: src/SUMMARY.md:86 src/pattern-matching.md:1
 msgid "Pattern Matching"
 msgstr "패턴 매칭"
 
-#: src/SUMMARY.md:86 src/pattern-matching/destructuring-enums.md:1
+#: src/SUMMARY.md:87 src/pattern-matching/destructuring-enums.md:1
 msgid "Destructuring Enums"
 msgstr "열거형 분해(역구조화)"
 
-#: src/SUMMARY.md:87 src/pattern-matching/destructuring-structs.md:1
+#: src/SUMMARY.md:88 src/pattern-matching/destructuring-structs.md:1
 msgid "Destructuring Structs"
 msgstr "구조체 분해(역구조화)"
 
-#: src/SUMMARY.md:88 src/pattern-matching/destructuring-arrays.md:1
+#: src/SUMMARY.md:89 src/pattern-matching/destructuring-arrays.md:1
 msgid "Destructuring Arrays"
 msgstr "배열 분해(역구조화)"
 
-#: src/SUMMARY.md:89 src/pattern-matching/match-guards.md:1
+#: src/SUMMARY.md:90 src/pattern-matching/match-guards.md:1
 msgid "Match Guards"
 msgstr "매치 가드"
 
-#: src/SUMMARY.md:91 src/exercises/day-2/health-statistics.md:1
+#: src/SUMMARY.md:92 src/exercises/day-2/health-statistics.md:1
 msgid "Health Statistics"
 msgstr "건강상태 모니터링 시스템"
 
-#: src/SUMMARY.md:92 src/exercises/day-2/solutions-morning.md:3
+#: src/SUMMARY.md:93 src/exercises/day-2/solutions-morning.md:3
 msgid "Points and Polygons"
 msgstr "점과 다각형"
 
-#: src/SUMMARY.md:94
+#: src/SUMMARY.md:95
 msgid "Day 2: Afternoon"
 msgstr "2일차 오후"
 
-#: src/SUMMARY.md:96 src/control-flow.md:1
+#: src/SUMMARY.md:97 src/SUMMARY.md:290 src/control-flow.md:1
 msgid "Control Flow"
 msgstr "흐름 제어"
 
-#: src/SUMMARY.md:97 src/control-flow/blocks.md:1
+#: src/SUMMARY.md:98 src/control-flow/blocks.md:1
 msgid "Blocks"
 msgstr "블록"
 
-#: src/SUMMARY.md:98
+#: src/SUMMARY.md:99
 msgid "if expressions"
 msgstr "if 표현식"
 
-#: src/SUMMARY.md:99
+#: src/SUMMARY.md:100
 msgid "if let expressions"
 msgstr "if let 표현식"
 
-#: src/SUMMARY.md:100
+#: src/SUMMARY.md:101
 msgid "while expressions"
 msgstr "while 표현식"
 
-#: src/SUMMARY.md:101
+#: src/SUMMARY.md:102
 msgid "while let expressions"
 msgstr "while let 표현식"
 
-#: src/SUMMARY.md:102
+#: src/SUMMARY.md:103
 msgid "for expressions"
 msgstr "for 표현식"
 
-#: src/SUMMARY.md:103
+#: src/SUMMARY.md:104
 msgid "loop expressions"
 msgstr "loop 표현식"
 
-#: src/SUMMARY.md:104
+#: src/SUMMARY.md:105
 msgid "match expressions"
 msgstr "match 표현식"
 
-#: src/SUMMARY.md:105
+#: src/SUMMARY.md:106
 msgid "break & continue"
 msgstr "break와 continue"
 
-#: src/SUMMARY.md:106 src/std.md:1
+#: src/SUMMARY.md:107 src/std.md:1
 msgid "Standard Library"
 msgstr "표준 라이브러리"
 
-#: src/SUMMARY.md:107
+#: src/SUMMARY.md:108
 msgid "Option and Result"
 msgstr "Option과 Result"
 
-#: src/SUMMARY.md:108 src/std/string.md:1
+#: src/SUMMARY.md:109 src/std/string.md:1
 msgid "String"
 msgstr "String"
 
-#: src/SUMMARY.md:109
+#: src/SUMMARY.md:110
 msgid "Vec"
 msgstr "Vec"
 
-#: src/SUMMARY.md:110
+#: src/SUMMARY.md:111
 msgid "HashMap"
 msgstr "HashMap"
 
-#: src/SUMMARY.md:111
+#: src/SUMMARY.md:112
 msgid "Box"
 msgstr "Box"
 
-#: src/SUMMARY.md:112
+#: src/SUMMARY.md:113
 msgid "Recursive Data Types"
 msgstr "재귀적 자료구조"
 
-#: src/SUMMARY.md:113 src/std/box-niche.md:1
+#: src/SUMMARY.md:114 src/std/box-niche.md:1
 msgid "Niche Optimization"
 msgstr "니치(틈새) 최적화(Niche Optimization)"
 
-#: src/SUMMARY.md:114
+#: src/SUMMARY.md:115
 msgid "Rc"
 msgstr "Rc"
 
-#: src/SUMMARY.md:115 src/modules.md:1
+#: src/SUMMARY.md:116
+msgid "Cell/RefCell"
+msgstr "Cell과 RefCell"
+
+#: src/SUMMARY.md:117 src/modules.md:1
 msgid "Modules"
 msgstr "모듈"
 
-#: src/SUMMARY.md:116 src/modules/visibility.md:1
+#: src/SUMMARY.md:118 src/modules/visibility.md:1
 msgid "Visibility"
 msgstr "가시성"
 
-#: src/SUMMARY.md:117 src/modules/paths.md:1
+#: src/SUMMARY.md:119 src/modules/paths.md:1
 msgid "Paths"
 msgstr "경로"
 
-#: src/SUMMARY.md:118 src/modules/filesystem.md:1
+#: src/SUMMARY.md:120 src/modules/filesystem.md:1
 msgid "Filesystem Hierarchy"
 msgstr "파일시스템 계층"
 
-#: src/SUMMARY.md:120 src/exercises/day-2/luhn.md:1
+#: src/SUMMARY.md:122 src/exercises/day-2/luhn.md:1
 #: src/exercises/day-2/solutions-afternoon.md:3
 msgid "Luhn Algorithm"
 msgstr "룬 알고리즘"
 
-#: src/SUMMARY.md:121 src/exercises/day-2/strings-iterators.md:1
-#: src/exercises/day-2/solutions-afternoon.md:98
+#: src/SUMMARY.md:123 src/exercises/day-2/strings-iterators.md:1
+#: src/exercises/day-2/solutions-afternoon.md:97
 msgid "Strings and Iterators"
 msgstr "문자열과 반복자"
 
-#: src/SUMMARY.md:124
+#: src/SUMMARY.md:126
 msgid "Day 3: Morning"
 msgstr "3일차 오전"
 
-#: src/SUMMARY.md:129 src/traits.md:1
-msgid "Traits"
-msgstr "트레잇(Trait)"
-
-#: src/SUMMARY.md:130 src/traits/deriving-traits.md:1
-msgid "Deriving Traits"
-msgstr "트레잇 상속하기"
-
-#: src/SUMMARY.md:131 src/traits/default-methods.md:1
-msgid "Default Methods"
-msgstr "기본 메서드"
-
-#: src/SUMMARY.md:132 src/traits/important-traits.md:1
-msgid "Important Traits"
-msgstr "중요한 트레잇"
-
-#: src/SUMMARY.md:133
-msgid "Iterator"
-msgstr "Iterator"
-
-#: src/SUMMARY.md:134 src/traits/from-iterator.md:1
-msgid "FromIterator"
-msgstr "FromIterator"
-
-#: src/SUMMARY.md:135
-msgid "From and Into"
-msgstr "From과 Into"
-
-#: src/SUMMARY.md:136
-msgid "Read and Write"
-msgstr "Read와 Write"
-
-#: src/SUMMARY.md:137
-msgid "Add, Mul, ..."
-msgstr "Add, Mul, ..."
-
-#: src/SUMMARY.md:138
-msgid "Drop"
-msgstr "Drop"
-
-#: src/SUMMARY.md:139
-msgid "Default"
-msgstr "Default"
-
-#: src/SUMMARY.md:140 src/generics.md:1
+#: src/SUMMARY.md:131 src/generics.md:1
 msgid "Generics"
 msgstr "제네릭"
 
-#: src/SUMMARY.md:141 src/generics/data-types.md:1
+#: src/SUMMARY.md:132 src/generics/data-types.md:1
 msgid "Generic Data Types"
 msgstr "제네릭 데이터 타입"
 
-#: src/SUMMARY.md:142 src/generics/methods.md:1
+#: src/SUMMARY.md:133 src/generics/methods.md:1
 msgid "Generic Methods"
 msgstr "제네릭 메서드"
 
-#: src/SUMMARY.md:143 src/generics/trait-bounds.md:1
-msgid "Trait Bounds"
-msgstr "제네릭 타입 제한(트레잇 경계)"
-
-#: src/SUMMARY.md:144
-msgid "impl Trait"
-msgstr "트레잇 구현하기"
-
-#: src/SUMMARY.md:145 src/generics/closures.md:1
-msgid "Closures"
-msgstr "클로저"
-
-#: src/SUMMARY.md:146 src/generics/monomorphization.md:1
+#: src/SUMMARY.md:134 src/generics/monomorphization.md:1
 msgid "Monomorphization"
 msgstr "단형화"
 
-#: src/SUMMARY.md:147 src/generics/trait-objects.md:1
+#: src/SUMMARY.md:135 src/traits.md:1
+msgid "Traits"
+msgstr "트레잇(Trait)"
+
+#: src/SUMMARY.md:136 src/traits/trait-objects.md:1
 msgid "Trait Objects"
 msgstr "트레잇 객체"
 
-#: src/SUMMARY.md:149 src/exercises/day-3/simple-gui.md:1
+#: src/SUMMARY.md:137 src/traits/deriving-traits.md:1
+msgid "Deriving Traits"
+msgstr "트레잇 상속하기"
+
+#: src/SUMMARY.md:138 src/traits/default-methods.md:1
+msgid "Default Methods"
+msgstr "기본 메서드"
+
+#: src/SUMMARY.md:139 src/traits/trait-bounds.md:1
+msgid "Trait Bounds"
+msgstr "제네릭 타입 제한(트레잇 경계)"
+
+#: src/SUMMARY.md:140
+msgid "impl Trait"
+msgstr "트레잇 구현하기"
+
+#: src/SUMMARY.md:141 src/traits/important-traits.md:1
+msgid "Important Traits"
+msgstr "중요한 트레잇"
+
+#: src/SUMMARY.md:142
+msgid "Iterator"
+msgstr "Iterator"
+
+#: src/SUMMARY.md:143 src/traits/from-iterator.md:1
+msgid "FromIterator"
+msgstr "FromIterator"
+
+#: src/SUMMARY.md:144
+msgid "From and Into"
+msgstr "From과 Into"
+
+#: src/SUMMARY.md:145
+msgid "Read and Write"
+msgstr "Read와 Write"
+
+#: src/SUMMARY.md:146
+msgid "Drop"
+msgstr "Drop"
+
+#: src/SUMMARY.md:147
+msgid "Default"
+msgstr "Default"
+
+#: src/SUMMARY.md:148
+msgid "Operators: Add, Mul, ..."
+msgstr "연산자: Add, Mul, ..."
+
+#: src/SUMMARY.md:149
+msgid "Closures: Fn, FnMut, FnOnce"
+msgstr "클로저: Fn, FnMut, FnOnce"
+
+#: src/SUMMARY.md:151 src/exercises/day-3/simple-gui.md:1
 #: src/exercises/day-3/solutions-morning.md:3
 msgid "A Simple GUI Library"
 msgstr "간단한 GUI 라이브러리"
 
-#: src/SUMMARY.md:151
+#: src/SUMMARY.md:153
 msgid "Day 3: Afternoon"
 msgstr "3일차 오후"
 
-#: src/SUMMARY.md:153 src/error-handling.md:1
+#: src/SUMMARY.md:155 src/error-handling.md:1
 msgid "Error Handling"
 msgstr "오류처리"
 
-#: src/SUMMARY.md:154 src/error-handling/panics.md:1
+#: src/SUMMARY.md:156 src/error-handling/panics.md:1
 msgid "Panics"
 msgstr "패닉"
 
-#: src/SUMMARY.md:155
+#: src/SUMMARY.md:157
 msgid "Catching Stack Unwinding"
 msgstr "스택 되감기"
 
-#: src/SUMMARY.md:156
+#: src/SUMMARY.md:158
 msgid "Structured Error Handling"
 msgstr "구조화된 오류처리"
 
-#: src/SUMMARY.md:157
+#: src/SUMMARY.md:159
 msgid "Propagating Errors with ?"
 msgstr "'?'를 이용한 오류 전파"
 
-#: src/SUMMARY.md:158 src/error-handling/converting-error-types.md:1
+#: src/SUMMARY.md:160 src/error-handling/converting-error-types.md:1
 #: src/error-handling/converting-error-types-example.md:1
 msgid "Converting Error Types"
 msgstr "오류타입 변환"
 
-#: src/SUMMARY.md:160 src/error-handling/deriving-error-enums.md:1
+#: src/SUMMARY.md:162 src/error-handling/deriving-error-enums.md:1
 msgid "Deriving Error Enums"
 msgstr "또다른 오류 열거형"
 
-#: src/SUMMARY.md:161 src/error-handling/dynamic-errors.md:1
+#: src/SUMMARY.md:163 src/error-handling/dynamic-errors.md:1
 msgid "Dynamic Error Types"
 msgstr "동적인 에러 타입"
 
-#: src/SUMMARY.md:162 src/error-handling/error-contexts.md:1
+#: src/SUMMARY.md:164 src/error-handling/error-contexts.md:1
 msgid "Adding Context to Errors"
 msgstr "오류에 상황정보 추가"
 
-#: src/SUMMARY.md:163 src/testing.md:1
+#: src/SUMMARY.md:165 src/testing.md:1
 msgid "Testing"
 msgstr "테스트"
 
-#: src/SUMMARY.md:164 src/testing/unit-tests.md:1
+#: src/SUMMARY.md:166 src/testing/unit-tests.md:1
 msgid "Unit Tests"
 msgstr "단위 테스트"
 
-#: src/SUMMARY.md:165 src/testing/test-modules.md:1
+#: src/SUMMARY.md:167 src/testing/test-modules.md:1
 msgid "Test Modules"
 msgstr "테스트 모듈"
 
-#: src/SUMMARY.md:166 src/testing/doc-tests.md:1
+#: src/SUMMARY.md:168 src/testing/doc-tests.md:1
 msgid "Documentation Tests"
 msgstr "문서화주석 테스트"
 
-#: src/SUMMARY.md:167 src/testing/integration-tests.md:1
+#: src/SUMMARY.md:169 src/testing/integration-tests.md:1
 msgid "Integration Tests"
 msgstr "통합 테스트"
 
-#: src/SUMMARY.md:168 src/unsafe.md:1
+#: src/SUMMARY.md:170 src/bare-metal/useful-crates.md:1
+msgid "Useful crates"
+msgstr "유용한 크레이트"
+
+#: src/SUMMARY.md:171 src/unsafe.md:1
 msgid "Unsafe Rust"
 msgstr "안전하지 않은 러스트"
 
-#: src/SUMMARY.md:169 src/unsafe/raw-pointers.md:1
+#: src/SUMMARY.md:172 src/unsafe/raw-pointers.md:1
 msgid "Dereferencing Raw Pointers"
 msgstr "원시 포인터 역참조(따라가기)"
 
-#: src/SUMMARY.md:170 src/unsafe/mutable-static-variables.md:1
+#: src/SUMMARY.md:173 src/unsafe/mutable-static-variables.md:1
 msgid "Mutable Static Variables"
 msgstr "정적 가변 변수"
 
-#: src/SUMMARY.md:171 src/unsafe/unions.md:1
+#: src/SUMMARY.md:174 src/unsafe/unions.md:1
 msgid "Unions"
 msgstr "Unions"
 
-#: src/SUMMARY.md:172 src/unsafe/calling-unsafe-functions.md:1
+#: src/SUMMARY.md:175 src/unsafe/calling-unsafe-functions.md:1
 msgid "Calling Unsafe Functions"
 msgstr "안전하지 않은 함수 호출"
 
-#: src/SUMMARY.md:173 src/unsafe/writing-unsafe-functions.md:1
+#: src/SUMMARY.md:176 src/unsafe/writing-unsafe-functions.md:1
 msgid "Writing Unsafe Functions"
 msgstr "안전하지 않은 함수 작성하기"
 
-#: src/SUMMARY.md:174
+#: src/SUMMARY.md:177
 msgid "Extern Functions"
 msgstr "외부(다른언어) 함수들"
 
-#: src/SUMMARY.md:175 src/unsafe/unsafe-traits.md:1
+#: src/SUMMARY.md:178 src/unsafe/unsafe-traits.md:1
 msgid "Implementing Unsafe Traits"
 msgstr "안전하지 않은 트레잇 구현하기"
 
-#: src/SUMMARY.md:177 src/exercises/day-3/safe-ffi-wrapper.md:1
+#: src/SUMMARY.md:180 src/exercises/day-3/safe-ffi-wrapper.md:1
 #: src/exercises/day-3/solutions-afternoon.md:3
 msgid "Safe FFI Wrapper"
 msgstr "FFI래퍼"
 
-#: src/SUMMARY.md:180
-msgid "Day 4: Morning"
-msgstr "4일차 오전"
-
-#: src/SUMMARY.md:185
-msgid "Concurrency"
-msgstr "동시성"
-
-#: src/SUMMARY.md:186 src/concurrency/threads.md:1
-msgid "Threads"
-msgstr "스레드"
-
-#: src/SUMMARY.md:187 src/concurrency/scoped-threads.md:1
-msgid "Scoped Threads"
-msgstr "범위 스레드(Scoped Threads)"
-
-#: src/SUMMARY.md:188 src/concurrency/channels.md:1
-msgid "Channels"
-msgstr "채널"
-
-#: src/SUMMARY.md:189 src/concurrency/channels/unbounded.md:1
-msgid "Unbounded Channels"
-msgstr "무경계 채널"
-
-#: src/SUMMARY.md:190 src/concurrency/channels/bounded.md:1
-msgid "Bounded Channels"
-msgstr "경계 채널"
-
-#: src/SUMMARY.md:191 src/concurrency/shared_state.md:1
-msgid "Shared State"
-msgstr "상태 공유"
-
-#: src/SUMMARY.md:192
-msgid "Arc"
-msgstr "Arc"
-
-#: src/SUMMARY.md:193
-msgid "Mutex"
-msgstr "Mutex"
-
-#: src/SUMMARY.md:195
-msgid "Send and Sync"
-msgstr "Send와 Sync"
-
-#: src/SUMMARY.md:195
-msgid "Send"
-msgstr "Send"
-
-#: src/SUMMARY.md:195
-msgid "Sync"
-msgstr "Sync"
-
-#: src/SUMMARY.md:198 src/concurrency/send-sync/examples.md:1
-msgid "Examples"
-msgstr "예제"
-
-#: src/SUMMARY.md:200 src/exercises/day-4/dining-philosophers.md:1
-#: src/exercises/day-4/solutions-morning.md:3
-msgid "Dining Philosophers"
-msgstr "식사하는 철학자들"
-
-#: src/SUMMARY.md:201 src/exercises/day-4/link-checker.md:1
-msgid "Multi-threaded Link Checker"
-msgstr "멀티스레드 링크 검사기"
-
-#: src/SUMMARY.md:203
-msgid "Day 4: Afternoon (Android)"
-msgstr "4일차 오후 (안드로이드)"
-
-#: src/SUMMARY.md:203 src/running-the-course/day-4.md:15 src/android.md:1
+#: src/SUMMARY.md:183 src/SUMMARY.md:253
+#: src/running-the-course/course-structure.md:16 src/bare-metal/android.md:1
 msgid "Android"
 msgstr "안드로이드"
 
-#: src/SUMMARY.md:208 src/android/setup.md:1
+#: src/SUMMARY.md:188 src/android/setup.md:1
 msgid "Setup"
 msgstr "설치"
 
-#: src/SUMMARY.md:209 src/android/build-rules.md:1
+#: src/SUMMARY.md:189 src/android/build-rules.md:1
 msgid "Build Rules"
 msgstr "빌드 규칙"
 
-#: src/SUMMARY.md:210
+#: src/SUMMARY.md:190
 msgid "Binary"
 msgstr "바이너리"
 
-#: src/SUMMARY.md:211
+#: src/SUMMARY.md:191
 msgid "Library"
 msgstr "라이브러리"
 
-#: src/SUMMARY.md:212 src/android/aidl.md:1
+#: src/SUMMARY.md:192 src/android/aidl.md:1
 msgid "AIDL"
 msgstr "AIDL"
 
-#: src/SUMMARY.md:213
+#: src/SUMMARY.md:193
 msgid "Interface"
 msgstr "AIDL 인터페이스"
 
-#: src/SUMMARY.md:214
+#: src/SUMMARY.md:194
 msgid "Implementation"
 msgstr "서비스 구현"
 
-#: src/SUMMARY.md:215
+#: src/SUMMARY.md:195
 msgid "Server"
 msgstr "AIDL 서버"
 
-#: src/SUMMARY.md:216 src/android/aidl/deploy.md:1
+#: src/SUMMARY.md:196 src/android/aidl/deploy.md:1
 msgid "Deploy"
 msgstr "배포"
 
-#: src/SUMMARY.md:217
+#: src/SUMMARY.md:197
 msgid "Client"
 msgstr "클라이언트"
 
-#: src/SUMMARY.md:218 src/android/aidl/changing.md:1
+#: src/SUMMARY.md:198 src/android/aidl/changing.md:1
 msgid "Changing API"
 msgstr "API 수정"
 
-#: src/SUMMARY.md:219 src/android/logging.md:1
+#: src/SUMMARY.md:199 src/SUMMARY.md:243 src/android/logging.md:1
+#: src/bare-metal/aps/logging.md:1
 msgid "Logging"
 msgstr "로깅"
 
-#: src/SUMMARY.md:220 src/android/interoperability.md:1
+#: src/SUMMARY.md:200 src/android/interoperability.md:1
 msgid "Interoperability"
 msgstr "상호운용성"
 
-#: src/SUMMARY.md:221
+#: src/SUMMARY.md:201
 msgid "With C"
 msgstr "C와의 상호운용성"
 
-#: src/SUMMARY.md:222
+#: src/SUMMARY.md:202
 msgid "Calling C with Bindgen"
 msgstr "Bindgen을 사용한 C호출"
 
-#: src/SUMMARY.md:223
+#: src/SUMMARY.md:203
 msgid "Calling Rust from C"
 msgstr "C에서 러스트 호출"
 
-#: src/SUMMARY.md:224 src/android/interoperability/cpp.md:1
+#: src/SUMMARY.md:204 src/android/interoperability/cpp.md:1
 msgid "With C++"
 msgstr "C++와의 상호운용성"
 
-#: src/SUMMARY.md:225
+#: src/SUMMARY.md:205
 msgid "With Java"
 msgstr "Java와의 상호운용성"
 
-#: src/SUMMARY.md:228
+#: src/SUMMARY.md:209
+msgid "Bare Metal: Morning"
+msgstr "Bare Metal 오전"
+
+#: src/SUMMARY.md:214
+msgid "no_std"
+msgstr "no_std"
+
+#: src/SUMMARY.md:215
+msgid "A Minimal Example"
+msgstr "작은 예제"
+
+#: src/SUMMARY.md:216
+msgid "alloc"
+msgstr "alloc"
+
+#: src/SUMMARY.md:217 src/bare-metal/microcontrollers.md:1
+msgid "Microcontrollers"
+msgstr "마이크로컨트롤러"
+
+#: src/SUMMARY.md:218 src/bare-metal/microcontrollers/mmio.md:1
+msgid "Raw MMIO"
+msgstr "원시 MMIO"
+
+#: src/SUMMARY.md:219
+msgid "PACs"
+msgstr "PAC"
+
+#: src/SUMMARY.md:220
+msgid "HAL Crates"
+msgstr "HAL 크레이트"
+
+#: src/SUMMARY.md:221
+msgid "Board Support Crates"
+msgstr "보드 지원 크레이트"
+
+#: src/SUMMARY.md:222
+msgid "The Type State Pattern"
+msgstr "Type State 패턴"
+
+#: src/SUMMARY.md:223
+msgid "embedded-hal"
+msgstr "embedded-hal"
+
+#: src/SUMMARY.md:224
+msgid "probe-rs, cargo-embed"
+msgstr "progo-rs, cargo-embed"
+
+#: src/SUMMARY.md:225 src/bare-metal/microcontrollers/debugging.md:1
+msgid "Debugging"
+msgstr "디버깅"
+
+#: src/SUMMARY.md:226 src/SUMMARY.md:246
+msgid "Other Projects"
+msgstr "다른 프로젝트"
+
+#: src/SUMMARY.md:228 src/exercises/bare-metal/compass.md:1
+#: src/exercises/bare-metal/solutions-morning.md:3
+msgid "Compass"
+msgstr "나침반"
+
+#: src/SUMMARY.md:230
+msgid "Bare Metal: Afternoon"
+msgstr "Bare Metal 오후"
+
+#: src/SUMMARY.md:232
+msgid "Application Processors"
+msgstr "애플리케이션 프로세서"
+
+#: src/SUMMARY.md:233 src/bare-metal/aps/entry-point.md:1
+msgid "Getting Ready to Rust"
+msgstr "Rust 수행 준비"
+
+#: src/SUMMARY.md:234
+msgid "Inline Assembly"
+msgstr "인라인 어셈블리"
+
+#: src/SUMMARY.md:235
+msgid "MMIO"
+msgstr "MMIO"
+
+#: src/SUMMARY.md:236
+msgid "Let's Write a UART Driver"
+msgstr "UART 드라이버 작성"
+
+#: src/SUMMARY.md:237
+msgid "More Traits"
+msgstr "더 많은 트레잇"
+
+#: src/SUMMARY.md:238
+msgid "A Better UART Driver"
+msgstr "더 나은 UART 드라이버"
+
+#: src/SUMMARY.md:239 src/bare-metal/aps/better-uart/bitflags.md:1
+msgid "Bitflags"
+msgstr "비트플래그"
+
+#: src/SUMMARY.md:240
+msgid "Multiple Registers"
+msgstr "더 많은 레지스터"
+
+#: src/SUMMARY.md:241 src/bare-metal/aps/better-uart/driver.md:1
+msgid "Driver"
+msgstr "드라이버"
+
+#: src/SUMMARY.md:242 src/SUMMARY.md:244
+msgid "Using It"
+msgstr "사용해 보기"
+
+#: src/SUMMARY.md:245 src/bare-metal/aps/exceptions.md:1
+msgid "Exceptions"
+msgstr "예외"
+
+#: src/SUMMARY.md:247
+msgid "Useful Crates"
+msgstr "유용한 크레이트"
+
+#: src/SUMMARY.md:248
+msgid "zerocopy"
+msgstr "zerocopy"
+
+#: src/SUMMARY.md:249
+msgid "aarch64-paging"
+msgstr "aarch64-paging"
+
+#: src/SUMMARY.md:250
+msgid "buddy_system_allocator"
+msgstr "buddy_system_allocator"
+
+#: src/SUMMARY.md:251
+msgid "tinyvec"
+msgstr "tinyvec"
+
+#: src/SUMMARY.md:252
+msgid "spin"
+msgstr "회전"
+
+#: src/SUMMARY.md:254 src/bare-metal/android/vmbase.md:1
+msgid "vmbase"
+msgstr "vmbase"
+
+#: src/SUMMARY.md:256
+msgid "RTC Driver"
+msgstr "RTC 드라이버"
+
+#: src/SUMMARY.md:259
+msgid "Concurrency: Morning"
+msgstr "동시성 오전"
+
+#: src/SUMMARY.md:264 src/concurrency/threads.md:1
+msgid "Threads"
+msgstr "스레드"
+
+#: src/SUMMARY.md:265 src/concurrency/scoped-threads.md:1
+msgid "Scoped Threads"
+msgstr "범위 스레드(Scoped Threads)"
+
+#: src/SUMMARY.md:266 src/concurrency/channels.md:1
+msgid "Channels"
+msgstr "채널"
+
+#: src/SUMMARY.md:267 src/concurrency/channels/unbounded.md:1
+msgid "Unbounded Channels"
+msgstr "무경계 채널"
+
+#: src/SUMMARY.md:268 src/concurrency/channels/bounded.md:1
+msgid "Bounded Channels"
+msgstr "경계 채널"
+
+#: src/SUMMARY.md:269
+msgid "Send and Sync"
+msgstr "Send와 Sync"
+
+#: src/SUMMARY.md:269
+msgid "Send"
+msgstr "Send"
+
+#: src/SUMMARY.md:269
+msgid "Sync"
+msgstr "Sync"
+
+#: src/SUMMARY.md:272 src/concurrency/send-sync/examples.md:1
+msgid "Examples"
+msgstr "예제"
+
+#: src/SUMMARY.md:273 src/concurrency/shared_state.md:1
+msgid "Shared State"
+msgstr "상태 공유"
+
+#: src/SUMMARY.md:274
+msgid "Arc"
+msgstr "Arc"
+
+#: src/SUMMARY.md:275
+msgid "Mutex"
+msgstr "Mutex"
+
+#: src/SUMMARY.md:278 src/SUMMARY.md:299
+#: src/exercises/concurrency/dining-philosophers.md:1
+#: src/exercises/concurrency/solutions-morning.md:3
+msgid "Dining Philosophers"
+msgstr "식사하는 철학자들"
+
+#: src/SUMMARY.md:279 src/exercises/concurrency/link-checker.md:1
+msgid "Multi-threaded Link Checker"
+msgstr "멀티스레드 링크 검사기"
+
+#: src/SUMMARY.md:281
+msgid "Concurrency: Afternoon"
+msgstr "동시성 오후"
+
+#: src/SUMMARY.md:283
+msgid "Async Basics"
+msgstr "비동기 관련 기본사항"
+
+#: src/SUMMARY.md:284
+msgid "async/await"
+msgstr "async/await"
+
+#: src/SUMMARY.md:285 src/async/futures.md:1
+msgid "Futures"
+msgstr "Future"
+
+#: src/SUMMARY.md:286 src/async/runtimes.md:1
+msgid "Runtimes"
+msgstr "비동기 런타임들"
+
+#: src/SUMMARY.md:287 src/async/runtimes/tokio.md:1
+msgid "Tokio"
+msgstr "Tokio"
+
+#: src/SUMMARY.md:288 src/exercises/concurrency/link-checker.md:126
+#: src/exercises/concurrency/chat-app.md:140 src/async/tasks.md:1
+msgid "Tasks"
+msgstr "태스크"
+
+#: src/SUMMARY.md:289 src/async/channels.md:1
+msgid "Async Channels"
+msgstr "비동기 채널"
+
+#: src/SUMMARY.md:291 src/async/control-flow/join.md:1
+msgid "Join"
+msgstr "Join"
+
+#: src/SUMMARY.md:292 src/async/control-flow/select.md:1
+msgid "Select"
+msgstr "Select"
+
+#: src/SUMMARY.md:293
+msgid "Pitfalls"
+msgstr "함정"
+
+#: src/SUMMARY.md:294
+msgid "Blocking the Executor"
+msgstr "Executor 블로킹 하기"
+
+#: src/SUMMARY.md:295 src/async/pitfalls/pin.md:1
+msgid "Pin"
+msgstr "Pin"
+
+#: src/SUMMARY.md:296 src/async/pitfalls/async-traits.md:1
+msgid "Async Traits"
+msgstr "비동기 트레잇"
+
+#: src/SUMMARY.md:297 src/async/pitfalls/cancellation.md:1
+msgid "Cancellation"
+msgstr "취소"
+
+#: src/SUMMARY.md:300 src/exercises/concurrency/chat-app.md:1
+#: src/exercises/concurrency/solutions-afternoon.md:119
+msgid "Broadcast Chat Application"
+msgstr "채팅 애플리케이션"
+
+#: src/SUMMARY.md:303
 msgid "Final Words"
 msgstr "끝으로..."
 
-#: src/SUMMARY.md:230 src/thanks.md:1
+#: src/SUMMARY.md:307 src/thanks.md:1
 msgid "Thanks!"
 msgstr "감사인사"
 
-#: src/SUMMARY.md:231
+#: src/SUMMARY.md:308
 msgid "Other Resources"
 msgstr "러스트 참고 자료"
 
-#: src/SUMMARY.md:232 src/credits.md:1
+#: src/SUMMARY.md:309 src/credits.md:1
 msgid "Credits"
 msgstr "도와주신 분들"
 
-#: src/SUMMARY.md:236 src/exercises/solutions.md:1
+#: src/SUMMARY.md:312 src/exercises/solutions.md:1
 msgid "Solutions"
 msgstr "해답"
 
-#: src/SUMMARY.md:241
+#: src/SUMMARY.md:317
 msgid "Day 1 Morning"
 msgstr "1일차 오전"
 
-#: src/SUMMARY.md:242
+#: src/SUMMARY.md:318
 msgid "Day 1 Afternoon"
 msgstr "1일차 오후"
 
-#: src/SUMMARY.md:243
+#: src/SUMMARY.md:319
 msgid "Day 2 Morning"
 msgstr "2일차 오전"
 
-#: src/SUMMARY.md:244
+#: src/SUMMARY.md:320
 msgid "Day 2 Afternoon"
 msgstr "2일차 오후"
 
-#: src/SUMMARY.md:245
+#: src/SUMMARY.md:321
 msgid "Day 3 Morning"
 msgstr "3일차 오전"
 
-#: src/SUMMARY.md:246
+#: src/SUMMARY.md:322
 msgid "Day 3 Afternoon"
 msgstr "3일차 오후"
 
-#: src/SUMMARY.md:247
-msgid "Day 4 Morning"
-msgstr "4일차 오전"
+#: src/SUMMARY.md:323
+msgid "Bare Metal Rust Morning"
+msgstr "Bare Metal 오전"
 
-#: src/welcome.md:3
+#: src/SUMMARY.md:324 src/exercises/bare-metal/solutions-afternoon.md:1
+msgid "Bare Metal Rust Afternoon"
+msgstr "전Bare Metal 오후"
+
+#: src/SUMMARY.md:325
+msgid "Concurrency Morning"
+msgstr "동시성 오전"
+
+#: src/SUMMARY.md:326
+msgid "Concurrency Afternoon"
+msgstr "동시성 오후"
+
+#: src/index.md:3
 msgid ""
 "[![Build workflow](https://img.shields.io/github/actions/workflow/status/"
 "google/comprehensive-rust/build.yml?style=flat-square)](https://github.com/"
-"google/comprehensive-rust/actions/workflows/build.yml)"
+"google/comprehensive-rust/actions/workflows/build.yml?query=branch%3Amain)"
 msgstr ""
+"[![Build workflow](https://img.shields.io/github/actions/workflow/status/"
+"google/comprehensive-rust/build.yml?style=flat-square)](https://github.com/"
+"google/comprehensive-rust/actions/workflows/build.yml?query=branch%3Amain)"
 
-#: src/welcome.md:3
+#: src/index.md:3
 msgid "Build workflow"
 msgstr "빌드 워크플로"
 
-#: src/welcome.md:3
+#: src/index.md:3
 msgid ""
 "[![Build workflow](https://img.shields.io/github/actions/workflow/status/"
 "google/comprehensive-rust/build.yml?style=flat-square)](https://github.com/"
-"google/comprehensive-rust/actions/workflows/build.yml) [![GitHub "
-"contributors](https://img.shields.io/github/contributors/google/"
+"google/comprehensive-rust/actions/workflows/build.yml?query=branch%3Amain) [!"
+"[GitHub contributors](https://img.shields.io/github/contributors/google/"
 "comprehensive-rust?style=flat-square)](https://github.com/google/"
 "comprehensive-rust/graphs/contributors)"
 msgstr ""
 "[![Build workflow](https://img.shields.io/github/actions/workflow/status/"
 "google/comprehensive-rust/build.yml?style=flat-square)](https://github.com/"
-"google/comprehensive-rust/actions/workflows/build.yml) [![GitHub "
-"contributors](https://img.shields.io/github/contributors/google/"
+"google/comprehensive-rust/actions/workflows/build.yml?query=branch%3Amain) [!"
+"[GitHub contributors](https://img.shields.io/github/contributors/google/"
 "comprehensive-rust?style=flat-square)](https://github.com/google/"
 "comprehensive-rust/graphs/contributors)"
 
-#: src/welcome.md:4
+#: src/index.md:4
 msgid "GitHub contributors"
 msgstr "GitHub 참여자"
 
-#: src/welcome.md:4
+#: src/index.md:4
 msgid ""
 "[![GitHub contributors](https://img.shields.io/github/contributors/google/"
 "comprehensive-rust?style=flat-square)](https://github.com/google/"
@@ -839,11 +1073,11 @@ msgstr ""
 "io/github/stars/google/comprehensive-rust?style=flat-square)](https://github."
 "com/google/comprehensive-rust/stargazers)"
 
-#: src/welcome.md:5
+#: src/index.md:5
 msgid "GitHub stars"
 msgstr "GitHub stars"
 
-#: src/welcome.md:5
+#: src/index.md:5
 msgid ""
 "[![GitHub stars](https://img.shields.io/github/stars/google/comprehensive-"
 "rust?style=flat-square)](https://github.com/google/comprehensive-rust/"
@@ -853,18 +1087,16 @@ msgstr ""
 "rust?style=flat-square)](https://github.com/google/comprehensive-rust/"
 "stargazers)"
 
-#: src/welcome.md:7
+#: src/index.md:7
 msgid ""
-"This is a four day Rust course developed by the Android team. The course "
-"covers the full spectrum of Rust, from basic syntax to advanced topics like "
-"generics and error handling. It also includes Android-specific content on "
-"the last day."
+"This is a free Rust course developed by the Android team at Google. The "
+"course covers the full spectrum of Rust, from basic syntax to advanced "
+"topics like generics and error handling."
 msgstr ""
-"이 4일짜리 러스트 강의는 안드로이드 팀이 만들었습니다. 기본 문법부터 제네릭, "
-"에러 핸들링과 같은 고급주제까지 러스트의 모든 것을 포함합니다. 마지막 날에는 "
-"안드로이드에 대한 것 까지 다룹니다."
+"이 강의는 무료이며, Google의 Android 팀이 만들었습니다. 기본 문법부터 제네"
+"릭, 에러 핸들링과 같은 고급주제까지 러스트의 모든 것을 포함합니다."
 
-#: src/welcome.md:11
+#: src/index.md:11
 msgid ""
 "The goal of the course is to teach you Rust. We assume you don't know "
 "anything about Rust and hope to:"
@@ -872,50 +1104,60 @@ msgstr ""
 "강의는 당신이 러스트에 대해서 아무것도 모른다고 가정하고 아래의 목표를 가지"
 "고 있습니다:"
 
-#: src/welcome.md:14
+#: src/index.md:14
 msgid "Give you a comprehensive understanding of the Rust syntax and language."
 msgstr "러스트 구문과 언어에 대한 포괄적인 이해를 제공합니다."
 
-#: src/welcome.md:15
+#: src/index.md:15
 msgid "Enable you to modify existing programs and write new programs in Rust."
 msgstr "기존 프로그램을 수정하고 러스트에서 새 프로그램을 작성할 수 있습니다."
 
-#: src/welcome.md:16
+#: src/index.md:16
 msgid "Show you common Rust idioms."
 msgstr "일반적인 러스트 관용구를 보여줍니다."
 
-#: src/welcome.md:18
-msgid "On Day 4, we will cover Android-specific things such as:"
-msgstr "4일차 강의에 우리는 아래와 같은 안드로이드 특화된 내용들도 설명합니다:"
+#: src/index.md:18
+msgid "We call the first three course days Rust Fundamentals."
+msgstr "강의의 첫 3일 동안에는 Rust의 기초를 다집니다."
 
-#: src/welcome.md:20
-msgid "Building Android components in Rust."
-msgstr "러스트에서 Android 구성 요소를 구축."
-
-#: src/welcome.md:21
-msgid "AIDL servers and clients."
-msgstr "AIDL 서버 및 클라이언트."
-
-#: src/welcome.md:22
-msgid "Interoperability with C, C++, and Java."
-msgstr "C, C++ 및 Java와의 상호 운용성."
-
-#: src/welcome.md:24
+#: src/index.md:20
 msgid ""
-"It is important to note that this course does not cover Android "
-"**application**  development in Rust, and that the Android-specific parts "
-"are specifically about writing code for Android itself, the operating "
-"system. "
-msgstr ""
-"이 강의에서는 러스트로 안드로이드 **애플리케이션**을 개발하는 것은 다루지 않"
-"습니다. 이 강의에서 다루는 안드로이드 특화된 내용은 안드로이드 OS의 일부를 러"
-"스트로 개발하는 것에 대한 것입니다. "
+"Building on this, you're invited to dive into one or more specialized topics:"
+msgstr "그 후에는, 아래와 같은 개별 주제를 심화해서 공부할 수 있습니다:"
 
-#: src/welcome.md:28
+#: src/index.md:22
+msgid ""
+"[Android](android.md): a half-day course on using Rust for Android platform "
+"development (AOSP). This includes interoperability with C, C++, and Java."
+msgstr ""
+"[Android](android.md): Android 플랫폼 개발(AOSP) 시 Rust 사용에 관한 반나절 "
+"과정입니다. 여기에는 C, C++, Java와의 상호 운용성이 포함됩니다."
+
+#: src/index.md:24
+msgid ""
+"[Bare-metal](bare-metal.md): a whole-day class on using Rust for bare-metal "
+"(embedded) development. Both microcontrollers and application processors are "
+"covered."
+msgstr ""
+"[Bare-metal](bare-metal.md): bare-metal(임베디드) 개발 시 Rust 사용에 관한 종"
+"일 과정입니다. 마이크로컨트롤러와 애플리케이션 프로세서를 모두 다룹니다."
+
+#: src/index.md:27
+msgid ""
+"[Concurrency](concurrency.md): a whole-day class on concurrency in Rust. We "
+"cover both classical concurrency (preemptively scheduling using threads and "
+"mutexes) and async/await concurrency (cooperative multitasking using "
+"futures)."
+msgstr ""
+"[동시성](concurrency.md): Rust의 동시성에 관한 종일 과정입니다. 여기서는 고전"
+"적인 동시성(스레드와 뮤텍스를 사용하여 선점형 스케줄링을 하는 것)과 async/"
+"await 동시성(future를 사용하는 협력적인 멀티태스킹)을 모두 다룹니다."
+
+#: src/index.md:33
 msgid "Non-Goals"
 msgstr "제외사항"
 
-#: src/welcome.md:30
+#: src/index.md:35
 msgid ""
 "Rust is a large language and we won't be able to cover all of it in a few "
 "days. Some non-goals of this course are:"
@@ -923,50 +1165,39 @@ msgstr ""
 "러스트는 며칠만에 모든 것을 다루기에는 너무 큰 언어입니다. 그래서 아래와 같은"
 "것을 목표로 하지 않습니다:"
 
-#: src/welcome.md:33
+#: src/index.md:38
 msgid ""
-"Learn how to use async Rust --- we'll only mention async Rust when covering "
-"traditional concurrency primitives. Please see [Asynchronous Programming in "
-"Rust](https://rust-lang.github.io/async-book/) instead for details on this "
-"topic."
-msgstr ""
-"비동기적 러스트 사용법. 간단하게 언급정도는 하겠지만 좀 더 자세한 내용은 "
-"[Asynchronous Programming in Rust](https://rust-lang.github.io/async-book/)"
-"를 참조해주세요."
-
-#: src/welcome.md:37
-msgid ""
-"Learn how to develop macros, please see [Chapter 19.5 in the Rust Book]"
+"Learning how to develop macros: please see [Chapter 19.5 in the Rust Book]"
 "(https://doc.rust-lang.org/book/ch19-06-macros.html) and [Rust by Example]"
 "(https://doc.rust-lang.org/rust-by-example/macros.html) instead."
 msgstr ""
-"매크로를 개발하는 방법. [Chapter 19.5 in the Rust Book](https://doc.rust-"
-"lang.org/book/ch19-06-macros.html)와 [Rust by Example](https://doc.rust-lang."
-"org/rust-by-example/macros.html)를 참조하세요."
+"매크로 만들기: 매크로와 관련한 자세한 내용은 [러스트 프로그래밍 언어, 19.1절]"
+"(https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html)과 [Rustonomicon]"
+"(https://doc.rust-lang.org/nomicon/)를 참조하세요."
 
-#: src/welcome.md:41
+#: src/index.md:42
 msgid "Assumptions"
 msgstr "독자 수준에 대한 가정"
 
-#: src/welcome.md:43
+#: src/index.md:44
 msgid ""
 "The course assumes that you already know how to program. Rust is a "
-"statically typed language and we will sometimes make comparisons with C and "
+"statically-typed language and we will sometimes make comparisons with C and "
 "C++ to better explain or contrast the Rust approach."
 msgstr ""
 "본 강의는 여러분이 프로그래밍 자체에 대해서는 알고 있다고 가정합니다. 러스트"
 "는 정적타입 언어이며, 강좌에서는 C/C++ 와의 비교, 대조를 통해 러스트를 설명"
 "할 것입니다."
 
-#: src/welcome.md:47
+#: src/index.md:48
 msgid ""
-"If you know how to program in a dynamically typed language such as Python or "
+"If you know how to program in a dynamically-typed language such as Python or "
 "JavaScript, then you will be able to follow along just fine too."
 msgstr ""
 "C/C++을 모르더라도 동적 타입 언어(Python이나 JavaScript 등) 프로그래밍 경험"
 "이 있다면 따라오는데 큰 문제는 없을 것입니다."
 
-#: src/welcome.md:52
+#: src/index.md:53
 msgid ""
 "This is an example of a _speaker note_. We will use these to add additional "
 "information to the slides. This could be key points which the instructor "
@@ -977,7 +1208,6 @@ msgstr ""
 "키 포인트일 수 있습니다."
 
 #: src/running-the-course.md:3 src/running-the-course/course-structure.md:3
-#: src/running-the-course/day-4.md:3
 msgid "This page is for the course instructor."
 msgstr "강사를 위한 안내 페이지입니다."
 
@@ -1008,26 +1238,20 @@ msgstr ""
 
 #: src/running-the-course.md:16
 msgid ""
-"Select your topic for the afternoon of the fourth day. This may be based on "
-"the audience you expect, or on your own expertise."
+"Decide on the dates. Since the course takes at least three full days, we "
+"recommend that you schedule the days over two weeks. Course participants "
+"have said that they find it helpful to have a gap in the course since it "
+"helps them process all the information we give them."
 msgstr ""
-"4일차 오후의 주제를 선택합니다. 수강생들이 원하는, 혹은 여러분이 자신있는 주"
-"제를 고르세요."
+"강의 날짜를 정합니다. 최소 3일에 걸쳐서 진행이 되기 때문에, 두 주에 걸쳐서 스"
+"케줄을 잡는 것을 권합니다. 기존 강의 수강생들의 피드백에 따르면, 연달아서 강"
+"의를 진행하는 것 보다, 강의를 띄엄띄엄 하는 것이 강의 내용을 소화하는데 더 도"
+"움이 되었다고 합니다."
 
-#: src/running-the-course.md:19
-msgid ""
-"Decide on the dates. Since the course is large, we recommend that you "
-"schedule the four days over two weeks. Course participants have said that "
-"they find it helpful to have a gap in the course since it helps them process "
-"all the information we give them."
-msgstr ""
-"강의 날짜를 정합니다. 강의 내용이 많고 수강생들이 모든 정보를 공부할 수 있도"
-"록 중간에 틈을 두어 2주에 걸쳐 4일을 잡는 것을 추천합니다."
-
-#: src/running-the-course.md:24
+#: src/running-the-course.md:21
 msgid ""
 "Find a room large enough for your in-person participants. We recommend a "
-"class size of 15-20 people. That's small enough that people are comfortable "
+"class size of 15-25 people. That's small enough that people are comfortable "
 "asking questions --- it's also small enough that one instructor will have "
 "time to answer the questions. Make sure the room has _desks_ for yourself "
 "and for the students: you will all need to be able to sit and work with your "
@@ -1035,11 +1259,11 @@ msgid ""
 "instructor, so a lectern won't be very helpful for you."
 msgstr ""
 "충분한 공간을 확보합니다. 15에서 20명 규모의 공간을 추천합니다. 수강생과 강사"
-"가 질의를 하기에 충분한 시간과 공간이어야 합니다. 강사나 수강생 모두 책상을 "
-"사용할 수 있는 강의실이면 좋습니다. 강의 중에 강사가 라이브 코딩을 하게 될 경"
-"우가 많으며, 이때 자리에 앉아 노트북을 사용하는 것이 도움이 됩니다."
+"가 질의를 하기에 충분한 시간과 공간이어야 합니다. 강사나 수강생 모두 \\_책상_"
+"을 사용할 수 있는 강의실이면 좋습니다. 강의 중에 강사가 라이브 코딩을 하게 "
+"될 경우가 많으며, 이때 자리에 앉아 노트북을 사용하는 것이 도움이 됩니다."
 
-#: src/running-the-course.md:32
+#: src/running-the-course.md:29
 msgid ""
 "On the day of your course, show up to the room a little early to set things "
 "up. We recommend presenting directly using `mdbook serve` running on your "
@@ -1048,31 +1272,30 @@ msgid ""
 "as you change pages. Using your laptop will also allow you to fix typos as "
 "you or the course participants spot them."
 msgstr ""
-"강의 당일 조금 일찍 와서 준비합니다. 강사 노트북에서 `mdbook serve -d book/"
-"ko`를 이용해 직접 프레젠테이션 하면 페이지 이동 시의 지연이 없습니다.([설치 "
-"방법](https://github.com/google/comprehensive-rust#building)을 참조하세요.) "
-"또한, 그렇게 하면 강의 도중 오타를 발견했을 때 그 자리에서 바로 수정 가능하다"
-"는 장점도 있습니다."
+"강의 당일 조금 일찍 와서 준비합니다. 강사 노트북에서 `mdbook serve`를 이용해 "
+"직접 프레젠테이션 하면 페이지 이동 시의 지연이 없습니다.([설치 방법](https://"
+"github.com/google/comprehensive-rust#building)을 참조하세요.) 또한, 그렇게 하"
+"면 강의 도중 오타를 발견했을 때 그 자리에서 바로 수정 가능하다는 장점도 있습"
+"니다."
 
-#: src/running-the-course.md:38
+#: src/running-the-course.md:35
 msgid ""
-"Let people solve the exercises by themselves or in small groups. Make sure "
-"to ask people if they're stuck or if there is anything you can help with. "
-"When you see that several people have the same problem, call it out to the "
-"class and offer a solution, e.g., by showing people where to find the "
-"relevant information in the standard library."
+"Let people solve the exercises by themselves or in small groups. We "
+"typically spend 30-45 minutes on exercises in the morning and in the "
+"afternoon (including time to review the solutions). Make sure to ask people "
+"if they're stuck or if there is anything you can help with. When you see "
+"that several people have the same problem, call it out to the class and "
+"offer a solution, e.g., by showing people where to find the relevant "
+"information in the standard library."
 msgstr ""
-"수강생들이 직접 (개별 혹은 그룹으로) 연습문제를 풀도록 합니다. 진행이 막혀 도"
-"움을 필요로 하는 수강생이 없는지 수시로 확인합니다. 만약 같은 문제를 여러 사"
-"람이 겪고 있다면, 그 문제를 강의실 전체 인원에게 알리고 해결책을 제시합니다. "
-"예를 들어 표준 라이브러리 어디에 가면 그 문제에 대한 해답을 찾을 수 있는지 알"
-"려 줍니다."
+"수강생들이 직접 (개별 혹은 그룹으로) 연습문제를 풀도록 합니다. 대체로 오전, "
+"오후에 각각 30-45분 정도를 연습문제에 할당합니다 (이는 해답을 보고 설명하는 "
+"시간까지 포함합니다). 막혀 도움을 필요로 하는 수강생이 없는지 수시로 확인합니"
+"다. 만약 같은 문제를 여러 사람이 겪고 있다면, 그 문제를 강의실 전체 인원에게 "
+"알리고 해결책을 제시합니다. 예를 들어 표준 라이브러리 어디에 가면 그 문제에 "
+"대한 해답을 찾을 수 있는지 알려 줍니다."
 
-#: src/running-the-course.md:44
-msgid "Prepare anything you need to have available for the afternoon of day 4."
-msgstr "4일차 오후에 필요한 것들을 준비하세요."
-
-#: src/running-the-course.md:46
+#: src/running-the-course.md:43
 msgid ""
 "That is all, good luck running the course! We hope it will be as much fun "
 "for you as it has been for us!"
@@ -1080,7 +1303,7 @@ msgstr ""
 "이제 준비는 끝났습니다. 우리가 그랬듯이 여러분들도 이 강의를 즐기시길 바랍니"
 "다!"
 
-#: src/running-the-course.md:49
+#: src/running-the-course.md:46
 msgid ""
 "Please [provide feedback](https://github.com/google/comprehensive-rust/"
 "discussions/86) afterwards so that we can keep improving the course. We "
@@ -1099,72 +1322,52 @@ msgstr "강의는 빠른 속도로 진행되며, 아래 내용들을 다룹니
 
 #: src/running-the-course/course-structure.md:7
 msgid "Day 1: Basic Rust, ownership and the borrow checker."
-msgstr "1일차: 러스트 기본, 소유권(ownership)과 빌림(borrow) 체크"
+msgstr "1일차: 러스트 기본, 소유권(ownership)과 빌림(borrow) 체크."
 
 #: src/running-the-course/course-structure.md:8
 msgid "Day 2: Compound data types,  pattern matching, the standard library."
-msgstr "2일차: 복합 데이터 유형, 패턴 매칭, 표준 라이브러리"
+msgstr "2일차: 복합 데이터 유형, 패턴 매칭, 표준 라이브러리."
 
 #: src/running-the-course/course-structure.md:9
 msgid "Day 3: Traits and generics, error handling, testing, unsafe Rust."
 msgstr ""
 "3일차: 트레잇(trait)와 제네릭(generic), 오류 처리, 테스트, 안전하지 않은 러스"
-"트"
+"트."
 
-#: src/running-the-course/course-structure.md:10
-msgid "Day 4: Concurrency in Rust and seeing Rust in action."
-msgstr "4일차: 러스트의 동시성 및 러스트가 실제 활용되는 사례 살펴보기"
+#: src/running-the-course/course-structure.md:11
+msgid "Deep Dives"
+msgstr "심화 학습"
 
-#: src/running-the-course/course-structure.md:12
-msgid "Format"
-msgstr "강의 형식"
-
-#: src/running-the-course/course-structure.md:14
+#: src/running-the-course/course-structure.md:13
 msgid ""
-"The course is meant to be very interactive and we recommend letting the "
-"questions drive the exploration of Rust!"
-msgstr ""
-"이 강의는 강사와 수강생이 양방향으로 소통하면서 진행하도록 디자인 되었습니"
-"다. 다양한 질문을 통해 러스트의 여러 부분을 탐험할 수 있도록 하세요!"
+"In addition to the 3-day class on Rust Fundamentals, we cover some more "
+"specialized topics:"
+msgstr "Rust 기초에 관한 3일 과정 이후에는, 다음과 같은 전문 주제를 다룹니다:"
 
-#: src/running-the-course/day-4.md:5
+#: src/running-the-course/course-structure.md:18
 msgid ""
-"The afternoon of the fourth day should cover a topic of your choice. Include "
-"the topic in the announcement of the course, so that participants know what "
-"to expect."
+"The [Android Deep Dive](../android.md) is a half-day course on using Rust "
+"for Android platform development. This includes interoperability with C, C+"
+"+, and Java."
 msgstr ""
-"4일차 오후에는 여러분의 선택에 따라 다른 주제를 다룰 수 있습니다. 강의를 안내"
-"할 때 4일차 오후의 주제를 포함하여 수강생들이 미리 알 수 있게 하세요."
+"[Android 심화 학습](../android.md)는 Android 플랫폼 개발 시 Rust 사용에 관한 "
+"반나절 과정입니다. 여기에는 C, C++, Java와의 상호 운용성이 포함됩니다."
 
-#: src/running-the-course/day-4.md:9
+#: src/running-the-course/course-structure.md:22
 msgid ""
-"This phase of the course is a chance for participants to see Rust in action "
-"on a codebase they might be familiar with. You can choose from the topics "
-"already defined here, or plan your own."
+"You will need an [AOSP checkout](https://source.android.com/docs/setup/"
+"download/downloading). Make a checkout of the [course repository](https://"
+"github.com/google/comprehensive-rust) on the same machine and move the `src/"
+"android/` directory into the root of your AOSP checkout. This will ensure "
+"that the Android build system sees the `Android.bp` files in `src/android/`."
 msgstr ""
-"4일차 쯤이면, 실제 코드 베이스를 통해 러스트가 활용되는 모습을 살펴보면 좋습"
-"니다. 이미 준비된 주제 중에서 고를 수도 있고, 여러분이 직접 준비한 주제를 다"
-"룰 수도 있습니다."
+"[AOSP 코드](https://source.android.com/docs/setup/download/downloading)를 여"
+"러분의 컴퓨터에 체크아웃해야 합니다. 그런 다음, 그 컴퓨터에서 [과정 저장소]"
+"(https://github.com/google/comprehensive-rust)를 체크아웃하고 `src/android/` "
+"디렉터리를 AOSP 코드의 루트로 이동합니다. 이렇게 하면 안드로이드 빌드 시스템"
+"에서 과제용으로 추가된 `Android.bp`파일을 인식할 수 있습니다."
 
-#: src/running-the-course/day-4.md:13
-msgid "Some topics need additional preparation:"
-msgstr "준비된 주제 (어떤 주제는 추가적인 준비가 필요합니다):"
-
-#: src/running-the-course/day-4.md:17
-msgid ""
-"If you chose Android for Day 4 afternoon, you will need an \\[AOSP "
-"checkout\\]\\[1\\]. Make a checkout of the \\[course repository\\]\\[2\\] on "
-"the same machine and move the `src/android/` directory into the root of your "
-"AOSP checkout. This will ensure that the Android build system sees the "
-"`Android.bp` files in `src/android/`."
-msgstr ""
-"4일차 오후에 안드로이드를 다루기로 했다면, \\[AOSP 코드\\]\\[1\\]를 체크아웃"
-"해야 합니다. 그런 다음, 같은 컴퓨터에서 \\[과정 저장소\\]\\[2\\]를 체크아웃하"
-"고 `src/android/` 디렉터리를 AOSP 코드의 루트로 이동합니다. 이렇게 하면 안드"
-"로이드 빌드 시스템에서 과제용으로 추가된 `Android.bp`파일을 인식할 수 있습니"
-"다."
-
-#: src/running-the-course/day-4.md:22
+#: src/running-the-course/course-structure.md:27
 msgid ""
 "Ensure that `adb sync` works with your emulator or real device and pre-build "
 "all Android examples using `src/android/build_all.sh`. Read the script to "
@@ -1175,23 +1378,83 @@ msgstr ""
 "보세요. 그 쉘 스크립트를 읽고, 그 안에서 수행되는 명령어들을 확인한 후 각 명"
 "령어들을 수동으로 실행해도 잘 되는지 확인하세요."
 
-#: src/running-the-course/day-4.md:26
-msgid "Async"
-msgstr "비동기"
+#: src/running-the-course/course-structure.md:34
+msgid "Bare-Metal"
+msgstr "Bare-Metal"
 
-#: src/running-the-course/day-4.md:28
+#: src/running-the-course/course-structure.md:36
 msgid ""
-"If you chose Async for Day 4 afternoon, you will need a fresh crate set up "
-"and the dependencies downloaded and ready to go. You can then copy/paste the "
-"examples into `src/main.rs` to experiment with them."
+"The [Bare-Metal Deep Dive](../bare-metal.md): a full day class on using Rust "
+"for bare-metal (embedded) development. Both microcontrollers and application "
+"processors are covered."
 msgstr ""
-"4일 차 오후에 비동기를 다루기로 했다면, 새 크레이트를 설정하고 몇 가지 의존성"
-"을 다운로드해 두어야 합니다. 그런 다음 예제를 `src/main.rs`에 복사/붙여넣기 "
-"하여 실험할 수 있습니다."
+"[Bare-Metal 심화 학습](../bare-metal.md): bare-metal(임베디드) 개발 시 Rust "
+"사용에 관한 종일 과정입니다. 마이크로컨트롤러와 애플리케이션 프로세서를 모두 "
+"다룹니다."
+
+#: src/running-the-course/course-structure.md:40
+msgid ""
+"For the microcontroller part, you will need to buy the [BBC micro:bit]"
+"(https://microbit.org/) v2 development board ahead of time. Everybody will "
+"need to install a number of packages as described on the [welcome page](../"
+"bare-metal.md)."
+msgstr ""
+"마이크로컨트롤러 파트를 진행하기 위해서는 [BBC micro:bit](https://microbit."
+"org/) v2 개발 보드를 미리 구매해야 합니다. 모든 사용자는 [시작 페이지](../"
+"bare-metal.md)에 설명된 대로 각종 패키지를 설치해야 합니다."
+
+#: src/running-the-course/course-structure.md:45
+msgid "Concurrency"
+msgstr "동시성"
+
+#: src/running-the-course/course-structure.md:47
+msgid ""
+"The [Concurrency Deep Dive](../concurrency.md) is a full day class on "
+"classical as well as `async`/`await` concurrency."
+msgstr ""
+"[동시성 심화학습](../concurrency.md)은 고전적인 동시성 및 `async`/`await` 동"
+"시성을 다루는 종일 과정입니다."
+
+#: src/running-the-course/course-structure.md:50
+msgid ""
+"You will need a fresh crate set up and the dependencies downloaded and ready "
+"to go. You can then copy/paste the examples into `src/main.rs` to experiment "
+"with them:"
+msgstr ""
+"새 크레이트를 설정하고 몇 가지 의존성을 다운로드해 두어야 합니다. 그런 다음 "
+"예제를 `src/main.rs`에 복사/붙여넣기 하여 테스트 해 볼 수 있습니다:"
+
+#: src/running-the-course/course-structure.md:54
+msgid ""
+"```shell\n"
+"cargo init concurrency\n"
+"cd concurrency\n"
+"cargo add tokio --features full\n"
+"cargo run\n"
+"```"
+msgstr ""
+"```shell\n"
+"cargo init concurrency\n"
+"cd concurrency\n"
+"cargo add tokio --features full\n"
+"cargo run\n"
+"```"
+
+#: src/running-the-course/course-structure.md:61
+msgid "Format"
+msgstr "강의 형식"
+
+#: src/running-the-course/course-structure.md:63
+msgid ""
+"The course is meant to be very interactive and we recommend letting the "
+"questions drive the exploration of Rust!"
+msgstr ""
+"이 강의는 강사와 수강생이 양방향으로 소통하면서 진행하도록 디자인 되었습니"
+"다. 다양한 질문을 통해 러스트의 여러 부분을 탐험할 수 있도록 하세요!"
 
 #: src/running-the-course/keyboard-shortcuts.md:3
 msgid "There are several useful keyboard shortcuts in mdBook:"
-msgstr "mdBook 시스템(현 사이트)에서 유용한 단축키들 입니다:"
+msgstr "다음은, mdBook 시스템(현 사이트)에서 유용한 단축키들 입니다:"
 
 #: src/running-the-course/keyboard-shortcuts.md:5
 msgid "Arrow-Left"
@@ -1231,30 +1494,29 @@ msgid ""
 "The course has been translated into other languages by a set of wonderful "
 "volunteers:"
 msgstr ""
-"이 과정은 다른 언어로도 제공됩니다. 괄호 안은 번역에 도움 주신 분들입니다."
+"이 과정은 다른 언어로도 제공됩니다. 괄호 안은 번역에 도움 주신 분들입니다:"
 
 #: src/running-the-course/translations.md:6
-#, fuzzy
 msgid ""
 "[Brazilian Portuguese](https://google.github.io/comprehensive-rust/pt-BR/) "
-"by [@rastringer](https://github.com/rastringer) and [@hugojacob](https://"
-"github.com/hugojacob)."
-msgstr "[영어](https://google.github.io/comprehensive-rust/)"
+"by [@rastringer](https://github.com/rastringer), [@hugojacob](https://github."
+"com/hugojacob), [@joaovicmendes](https://github.com/joaovicmendes) and "
+"[@henrif75](https://github.com/henrif75)."
+msgstr ""
+"[브라질 포르투갈어](https://google.github.io/comprehensive-rust/pt-BR/): "
+"[@rastringer](https://github.com/rastringer), [@hugojacob](https://github."
+"com/hugojacob), [@joaovicmendes](https://github.com/joaovicmendes) 그리고 "
+"[@henrif75](https://github.com/henrif75)가 제공."
 
 #: src/running-the-course/translations.md:7
-#, fuzzy
 msgid ""
 "[Korean](https://google.github.io/comprehensive-rust/ko/) by [@keispace]"
 "(https://github.com/keispace), [@jiyongp](https://github.com/jiyongp) and "
 "[@jooyunghan](https://github.com/jooyunghan)."
 msgstr ""
-"[브라질 포르투갈어](https://google.github.io/comprehensive-rust/pt-BR/) "
-"([@rastringer](https://github.com/rastringer), [@hugojacob](https://github."
-"com/hugojacob)).\n"
-"\n"
-"[한국어](https://google.github.io/comprehensive-rust/ko/) ([@keispace]"
-"(https://github.com/keispace), [@jiyongp](https://github.com/jiyongp), "
-"[@jooyunghan](https://github.com/jooyunghan))"
+"[한국어](https://google.github.io/comprehensive-rust/ko/): [@keispace]"
+"(https://github.com/keispace), [@jiyongp](https://github.com/jiyongp) 그리고 "
+"[@jooyunghan](https://github.com/jooyunghan)가 제공."
 
 #: src/running-the-course/translations.md:9
 msgid ""
@@ -1262,6 +1524,52 @@ msgid ""
 msgstr "페이지 오른쪽 위의 메뉴를 통해 다른 언어로 전환할 수 있습니다."
 
 #: src/running-the-course/translations.md:11
+msgid "Incomplete Translations"
+msgstr "번역 문제"
+
+#: src/running-the-course/translations.md:13
+msgid ""
+"There is a large number of in-progress translations. We link to the most "
+"recently updated translations:"
+msgstr ""
+"진행 중인 번역이 많습니다. 최근에 업데이트된 번역본으로 연결되는 링크는 다음"
+"과 같습니다:"
+
+#: src/running-the-course/translations.md:16
+msgid ""
+"[Bengali](https://google.github.io/comprehensive-rust/bn/) by [@raselmandol]"
+"(https://github.com/raselmandol)."
+msgstr ""
+"[벵갈어](https://google.github.io/comprehensive-rust/bn/): [@raselmandol]"
+"(https://github.com/raselmandol) 제공."
+
+#: src/running-the-course/translations.md:17
+msgid ""
+"[French](https://google.github.io/comprehensive-rust/fr/) by [@KookaS]"
+"(https://github.com/KookaS) and [@vcaen](https://github.com/vcaen)."
+msgstr ""
+"[프랑스어](https://google.github.io/comprehensive-rust/fr/): [@KookaS]"
+"(https://github.com/KookaS) 및 [@vcaen](https://github.com/vcaen) 제공."
+
+#: src/running-the-course/translations.md:18
+msgid ""
+"[German](https://google.github.io/comprehensive-rust/de/) by [@Throvn]"
+"(https://github.com/Throvn) and [@ronaldfw](https://github.com/ronaldfw)."
+msgstr ""
+"[독일어](https://google.github.io/comprehensive-rust/de/): [@Throvn](https://"
+"github.com/Throvn) 및 [@ronaldfw](https://github.com/ronaldfw) 제공."
+
+#: src/running-the-course/translations.md:19
+msgid ""
+"[Japanese](https://google.github.io/comprehensive-rust/ja/) by [@CoinEZ-JPN]"
+"(https://github.com/CoinEZ) and [@momotaro1105](https://github.com/"
+"momotaro1105)."
+msgstr ""
+"[일본어](https://google.github.io/comprehensive-rust/ja/): [@CoinEZ-JPN]"
+"(https://github.com/CoinEZ) 및 [@momotaro1105](https://github.com/"
+"momotaro1105) 제공."
+
+#: src/running-the-course/translations.md:21
 msgid ""
 "If you want to help with this effort, please see [our instructions](https://"
 "github.com/google/comprehensive-rust/blob/main/TRANSLATIONS.md) for how to "
@@ -1273,108 +1581,6 @@ msgstr ""
 "중인 번역 작업에 대한 내용은 [이슈 트래커](https://github.com/google/"
 "comprehensive-rust/issues/282)를 참고하세요."
 
-#: src/running-the-course/translations.md:13
-msgid ""
-"There is a large number of in-progress translations. We link to the most "
-"recently updated translations:"
-msgstr ""
-"진행 중인 번역이 많습니다. 최근에 업데이트된 번역본으로 연결되는 링크는 다음"
-"과 같습니다."
-
-#: src/running-the-course/translations.md:16
-msgid ""
-"[French](https://google.github.io/comprehensive-rust/fr/) by [@KookaS]"
-"(https://github.com/KookaS) and [@vcaen](https://github.com/vcaen)."
-msgstr ""
-"[French](https://google.github.io/comprehensive-rust/fr/): [@KookaS](https://"
-"github.com/KookaS) 및 [@vcaen](https://github.com/vcaen) 제공"
-
-#: src/running-the-course/translations.md:17
-msgid ""
-"[German](https://google.github.io/comprehensive-rust/de/) by [@Throvn]"
-"(https://github.com/Throvn) and [@ronaldfw](https://github.com/ronaldfw)."
-msgstr ""
-"[German](https://google.github.io/comprehensive-rust/de/): [@Throvn](https://"
-"github.com/Throvn) 및 [@ronaldfw](https://github.com/ronaldfw) 제공"
-
-#: src/running-the-course/translations.md:18
-msgid ""
-"[Japanese](https://google.github.io/comprehensive-rust/ja/) by [@CoinEZ-JPN]"
-"(https://github.com/CoinEZ) and [@momotaro1105](https://github.com/"
-"momotaro1105)."
-msgstr ""
-"[Japanese](https://google.github.io/comprehensive-rust/ja/): [@CoinEZ-JPN]"
-"(https://github.com/CoinEZ) 및 [@momotaro1105](https://github.com/"
-"momotaro1105) 제공"
-
-#: src/running-the-course/course-structure.md:11
-msgid "Deep Dives"
-msgstr "심화 학습"
-
-#: src/running-the-course/course-structure.md:13
-msgid ""
-"In addition to the 3-day class on Rust Fundamentals, we cover some more "
-"specialized topics:"
-msgstr "Rust 기초에 관한 3일 과정 외에도 다음과 같은 전문 주제를 다룹니다."
-
-#: src/running-the-course/course-structure.md:18
-msgid ""
-"The [Android Deep Dive](../android.md) is a half-day course on using Rust "
-"for Android platform development. This includes interoperability with C, C+"
-"+, and Java."
-msgstr ""
-"[Android 심화 학습](../android.md)는 Android 플랫폼 개발 시 Rust 사용에 관한 "
-"반나절 과정입니다. 여기에는 C, C++, Java와의 상호 운용성이 포함됩니다."
-
-#: src/running-the-course/course-structure.md:34
-msgid "Bare-Metal"
-msgstr "Bare-Metal"
-
-#: src/running-the-course/course-structure.md:36
-msgid ""
-"The [Bare-Metal Deep Dive](../bare-metal.md): a full day class on using Rust "
-"for bare-metal (embedded) development. Both microcontrollers and application "
-"processors are covered."
-msgstr ""
-"[Bare-Metal 심화 학습](../bare-metal.md): bare-metal(임베디드) 개발 시 Rust "
-"사용에 관한 종일 과정입니다. 마이크로컨트롤러와 애플리케이션 프로세서를 모두 "
-"다룹니다."
-
-#: src/running-the-course/course-structure.md:40
-msgid ""
-"For the microcontroller part, you will need to buy the [BBC micro:bit]"
-"(https://microbit.org/) v2 development board ahead of time. Everybody will "
-"need to install a number of packages as described on the [welcome page](../"
-"bare-metal.md)."
-msgstr ""
-"마이크로컨트롤러 파트를 진행하기 위해서는 [BBC micro:bit](https://microbit."
-"org/) v2 개발 보드를 미리 구매해야 합니다. 모든 사용자는 [시작 페이지](../"
-"bare-metal.md)에 설명된 대로 각종 패키지를 설치해야 합니다."
-
-#: src/running-the-course/course-structure.md:47
-msgid ""
-"The [Concurrency Deep Dive](../concurrency.md) is a full day class on "
-"classical as well as `async`/`await` concurrency."
-msgstr ""
-"[동시성 심화학습](../concurrency.md)은 고전적인 동시성 및 `async`/`await` 동"
-"시성을 다루는 종일 과정입니다."
-
-#: src/running-the-course/course-structure.md:54
-msgid ""
-"```shell\n"
-"cargo init concurrency\n"
-"cd concurrency\n"
-"cargo add tokio --features full\n"
-"cargo run\n"
-"```"
-msgstr ""
-"```shell\n"
-"cargo init concurrency\n"
-"cd concurrency\n"
-"cargo add tokio --features full\n"
-"cargo run\n"
-"```"
-
 #: src/cargo.md:3
 msgid ""
 "When you start reading about Rust, you will soon meet [Cargo](https://doc."
@@ -1393,65 +1599,53 @@ msgid "Installation"
 msgstr "설치하기"
 
 #: src/cargo.md:10
-msgid "Rustup (Recommended)"
-msgstr "Rustup (추천)"
+msgid "**Please follow the instructions on <https://rustup.rs/>.**"
+msgstr "**<https://rustup.rs/>의 설치 방법을 따르세요.**"
 
 #: src/cargo.md:12
 msgid ""
-"You can follow the instructions to install cargo and rust compiler, among "
-"other standard ecosystem tools with the [rustup](https://rust-analyzer."
-"github.io/) tool, which is maintained by the Rust Foundation."
+"This will give you the Cargo build tool (`cargo`) and the Rust compiler "
+"(`rustc`). You will also get `rustup`, a command line utility that you can "
+"use to install/switch toolchains, setup cross compilation, etc."
 msgstr ""
-"러스트 재단에서 관리하고 있는 [rustup](https://rust-analyzer.github.io/) 도구"
-"를 사용하여 카고 및 러스트 컴파일러 등 표준 도구를 설치 할 수 있습니다."
-
-#: src/cargo.md:14
-msgid ""
-"Along with cargo and rustc, Rustup will install itself as a command line "
-"utility that you can use to install/switch toolchains, setup cross "
-"compilation, etc."
-msgstr ""
-"카고(cargo)와 러스트 컴파일러(rustc)와 함께, rustup은 툴체인을 설치하고, 다"
+"위 설치 방법을 따르면, 빌드 시스템인 카고(`cargo`)와 러스트 컴파일러(`rustc`)"
+"가 설치됩니다. 이와 함께, `rustup`도 설치되는데 이 툴은 툴체인을 설치하고, 다"
 "른 툴체인으로 전환하고, 크로스 컴파일 설정을 하는 일을 담당하는 커맨드 라인 "
 "유틸리티 입니다."
 
 #: src/cargo.md:16
-msgid "Package Managers"
-msgstr "패키지 매니저"
+msgid ""
+"On Debian/Ubuntu, you can also install Cargo, the Rust source and the [Rust "
+"formatter](https://github.com/rust-lang/rustfmt) via `apt`. However, this "
+"gets you an outdated rust version and may lead to unexpected behavior. The "
+"command would be:"
+msgstr ""
+"데비안/우분투 시스템에서는 `apt`를 이용해서 카고, 러스트 소스, [러스트 포매"
+"터](https://github.com/rust-lang/rustfmt)를 설치할 수 있습니다. 그러나 이 방"
+"법을 따를 경우 최신 버전이 아닌 러스트를 사용게되며, 그 결과 예상치 못한 문제"
+"를 겪을 수도 있습니다. 설치 명령어는 아래와 같습니다:"
 
 #: src/cargo.md:18
-msgid "Debian"
-msgstr "데비안"
-
-#: src/cargo.md:20
 msgid ""
-"On Debian/Ubuntu, you can install Cargo, the Rust source and the [Rust "
-"formatter](https://github.com/rust-lang/rustfmt) with"
+"```shell\n"
+"    sudo apt install cargo rust-src rustfmt\n"
+"```"
 msgstr ""
-"데비안이나 우분투에서 cargo, 러스트 소스코드, [러스트 포매터](https://github."
-"com/rust-lang/rustfmt)를 아래 커맨드로 설치합니다."
+"```shell\n"
+"$ sudo apt install cargo rust-src rustfmt\n"
+"```"
 
 #: src/cargo.md:22
 msgid ""
-"```shell\n"
-"$ sudo apt install cargo rust-src rustfmt\n"
-"```"
+"We suggest using [VS Code](https://code.visualstudio.com/) to edit the code "
+"(but any LSP compatible editor works with rust-analyzer[3](https://rust-"
+"analyzer.github.io/))."
 msgstr ""
-"```shell\n"
-"$ sudo apt install cargo rust-src rustfmt\n"
-"```"
+"우리는 코드 에디터로 [VS Code](https://code.visualstudio.com/)를 추천합니다. "
+"그러나 LSP를 지원하는 (그래서 rust-analyzer[3](https://rust-analyzer.github."
+"io/)와 연동이 가능한) 에디터라면 어떤 것이라도 괜찮습니다."
 
-#: src/cargo.md:26
-msgid ""
-"This will allow \\[rust-analyzer\\]\\[1\\] to jump to the definitions. We "
-"suggest using [VS Code](https://code.visualstudio.com/) to edit the code "
-"(but any LSP compatible editor works)."
-msgstr ""
-"이렇게 하면 \\[rust-analyzer\\]\\[1\\]를 이용해서 특정 심볼이 정의된 위치로 "
-"쉽게 이동할 수 있습니다. 우리는 에디터로 [VS Code](https://code.visualstudio."
-"com/)를 추천합니다만, 사실 LSP를 지원한다면 어떤 에디터도 무방합니다."
-
-#: src/cargo.md:29
+#: src/cargo.md:24
 msgid ""
 "Some folks also like to use the [JetBrains](https://www.jetbrains.com/"
 "clion/) family of IDEs, which do their own analysis but have their own "
@@ -1487,14 +1681,14 @@ msgstr ""
 #: src/cargo/rust-ecosystem.md:8
 msgid ""
 "`cargo`: the Rust dependency manager and build tool. Cargo knows how to "
-"download dependencies hosted on <https://crates.io> and it will pass them to "
-"`rustc` when building your project. Cargo also comes with a built-in test "
-"runner which is used to execute unit tests."
+"download dependencies, usually hosted on <https://crates.io>, and it will "
+"pass them to `rustc` when building your project. Cargo also comes with a "
+"built-in test runner which is used to execute unit tests."
 msgstr ""
-"`cargo`: 러스트 의존성 관리자 및 빌드도구 입니다. 여러분의 프로젝트에 명시된 "
-"의존성들을 <https://crates.io>에서 자동으로 다운로드 받고, 그 소스코드를 "
-"`rustc`로 전달하여 빌드를 시킵니다. 또한 유닛 테스트를 실행하는 테스트 러너"
-"를 내장하고 있습니다."
+"`cargo`: 러스트 의존성 관리자이자 빌드 시스템 입니다. 여러분의 프로젝트에 명"
+"시된 의존성들을 <https://crates.io>에서 자동으로 다운로드 받고, 그 소스코드"
+"를 `rustc`로 전달하여 빌드를 시킵니다. 또한 유닛 테스트를 실행하는 테스트 러"
+"너를 내장하고 있습니다."
 
 #: src/cargo/rust-ecosystem.md:13
 msgid ""
@@ -1504,19 +1698,20 @@ msgid ""
 "standard library. You can have multiple versions of Rust installed at once "
 "and `rustup` will let you switch between them as needed."
 msgstr ""
-"`rustup`: 러스트 툴체인 설치 프로그램 및 업데이트 프로그램. 이 도구는 새 버전"
-"의 러스트가 출시될 때 `rustc` 및 `cargo` 설치하고 업데이트하는 데 사용됩니"
-"다. 또한 `rustup`은 표준 라이브러리에 대한 문서를 다운로드할 수도 있습니다. "
-"한 번에 여러 버전의 러스트를 설치할 수 있으며 `rustup`을 통해 필요에 따라 이"
-"들 버전을 전환할 수 있습니다."
+"`rustup`: 러스트 툴체인 설치 프로그램이자 업데이트 프로그램 입니다. 이 도구"
+"는 새 버전의 러스트가 출시될 때 `rustc` 및 `cargo` 설치하고 업데이트하는 데 "
+"사용됩니다. 또한 `rustup`은 표준 라이브러리에 대한 문서를 다운로드할 수도 있"
+"습니다. 한 번에 여러 버전의 러스트를 설치할 수 있으며 `rustup`을 이용해서 실"
+"제로 사용할 버전을 변경할 수 있습니다."
 
 #: src/cargo/rust-ecosystem.md:21 src/hello-world.md:25
 #: src/hello-world/small-example.md:27 src/why-rust/runtime.md:10
 #: src/why-rust/modern.md:21 src/basic-syntax/compound-types.md:30
+#: src/basic-syntax/references.md:23
 #: src/pattern-matching/destructuring-enums.md:35
-#: src/error-handling/try-operator.md:50
+#: src/error-handling/try-operator.md:48
 #: src/error-handling/converting-error-types-example.md:50
-#: src/concurrency/threads.md:30
+#: src/concurrency/threads.md:30 src/async/async-await.md:25
 msgid "Key points:"
 msgstr "키 포인트:"
 
@@ -1544,6 +1739,14 @@ msgstr ""
 
 #: src/cargo/rust-ecosystem.md:32
 msgid ""
+"Dependencies can also be resolved from alternative [registries](https://doc."
+"rust-lang.org/cargo/reference/registries.html), git, folders, and more."
+msgstr ""
+"의존성은 다양한 [저장소](registries), git 프로젝트, 디렉터리 등에서 제공될 "
+"수 있습니다."
+
+#: src/cargo/rust-ecosystem.md:34
+msgid ""
 "Rust also has [editions](https://doc.rust-lang.org/edition-guide/): the "
 "current edition is Rust 2021. Previous editions were Rust 2015 and Rust 2018."
 msgstr ""
@@ -1551,13 +1754,13 @@ msgstr ""
 "현재는 Rust 2021 에디션입니다. 이 전 에디션으로 Rust 2015와 Rust 2018이 있습"
 "니다."
 
-#: src/cargo/rust-ecosystem.md:35
+#: src/cargo/rust-ecosystem.md:37
 msgid ""
 "The editions are allowed to make backwards incompatible changes to the "
 "language."
 msgstr "에디션은 이전 에디션과 호환이 되지 않을 수 있습니다."
 
-#: src/cargo/rust-ecosystem.md:38
+#: src/cargo/rust-ecosystem.md:40
 msgid ""
 "To prevent breaking code, editions are opt-in: you select the edition for "
 "your crate via the `Cargo.toml` file."
@@ -1565,7 +1768,7 @@ msgstr ""
 "에디션이 바뀌면서 프로그램이 의도치 않게 깨지는 문제를 막기 위해, 각 프로그램"
 "은 자신이 빌드될 에디션을 명시적으로 `Cargo.toml`에 지정해야 합니다."
 
-#: src/cargo/rust-ecosystem.md:41
+#: src/cargo/rust-ecosystem.md:43
 msgid ""
 "To avoid splitting the ecosystem, Rust compilers can mix code written for "
 "different editions."
@@ -1573,7 +1776,7 @@ msgstr ""
 "러스트 생태계가 에디션 별로 파편회 되는 것을 막기 위해, 러스트 컴파일러는 서"
 "로 다른 에디션에서 작성된 코드들을 하나의 바이너리로 묶을 수 있습니다."
 
-#: src/cargo/rust-ecosystem.md:44
+#: src/cargo/rust-ecosystem.md:46
 msgid ""
 "Mention that it is quite rare to ever use the compiler directly not through "
 "`cargo` (most users never do)."
@@ -1581,51 +1784,51 @@ msgstr ""
 "`cargo`를 사용하지 않고 컴파일러를 직접 사용하는 경우는 거의 없음을 언급해 주"
 "시기 바랍니다."
 
-#: src/cargo/rust-ecosystem.md:46
+#: src/cargo/rust-ecosystem.md:48
 msgid ""
 "It might be worth alluding that Cargo itself is an extremely powerful and "
 "comprehensive tool.  It is capable of many advanced features including but "
 "not limited to: "
 msgstr ""
 "카고 자체가 매우 강력하고 포괄적인 도구임을 적극적으로 알리세요. 카고는 다음"
-"과 같은 다양한 고급 기능을 제공합니다."
+"과 같은 다양한 고급 기능을 제공합니다: "
 
-#: src/cargo/rust-ecosystem.md:47
+#: src/cargo/rust-ecosystem.md:49
 msgid "Project/package structure"
 msgstr "프로젝트/패키지 구조화"
 
-#: src/cargo/rust-ecosystem.md:48
+#: src/cargo/rust-ecosystem.md:50
 msgid "[workspaces](https://doc.rust-lang.org/cargo/reference/workspaces.html)"
 msgstr ""
 "[워크스페이스](https://doc.rust-lang.org/cargo/reference/workspaces.html)"
 
-#: src/cargo/rust-ecosystem.md:49
+#: src/cargo/rust-ecosystem.md:51
 msgid "Dev Dependencies and Runtime Dependency management/caching"
 msgstr "개발/런타임 종속성 관리 및 캐싱"
 
-#: src/cargo/rust-ecosystem.md:50
+#: src/cargo/rust-ecosystem.md:52
 msgid ""
 "[build scripting](https://doc.rust-lang.org/cargo/reference/build-scripts."
 "html)"
 msgstr ""
 "[빌드 스크립트](https://doc.rust-lang.org/cargo/reference/build-scripts.html)"
 
-#: src/cargo/rust-ecosystem.md:51
+#: src/cargo/rust-ecosystem.md:53
 msgid ""
 "[global installation](https://doc.rust-lang.org/cargo/commands/cargo-install."
 "html)"
 msgstr ""
 "[전역 설치](https://doc.rust-lang.org/cargo/commands/cargo-install.html)"
 
-#: src/cargo/rust-ecosystem.md:52
+#: src/cargo/rust-ecosystem.md:54
 msgid ""
 "It is also extensible with sub command plugins as well (such as [cargo "
 "clippy](https://github.com/rust-lang/rust-clippy))."
 msgstr ""
 "[cargo clippy](https://github.com/rust-lang/rust-clippy)와 같은 하위 플러그인"
-"으로 확장 가능"
+"으로 확장 가능."
 
-#: src/cargo/rust-ecosystem.md:53
+#: src/cargo/rust-ecosystem.md:55
 msgid ""
 "Read more from the [official Cargo Book](https://doc.rust-lang.org/cargo/)"
 msgstr ""
@@ -1680,7 +1883,7 @@ msgstr "코드 블록에 포커스를 두고 "
 
 #: src/cargo/code-samples.md:19
 msgid " to execute the code when focus is in the text box."
-msgstr "를 눌러 실행해 볼 수 있습니다."
+msgstr " 를 눌러 실행해 볼 수 있습니다."
 
 #: src/cargo/code-samples.md:24
 msgid ""
@@ -1743,24 +1946,32 @@ msgstr ""
 
 #: src/cargo/running-locally.md:15
 msgid ""
-"With this is in place, then follow these steps to build a Rust binary from "
-"one of the examples in this training:"
+"You can use any later version too since Rust maintains backwards "
+"compatibility."
 msgstr ""
-"정상적으로 설치가 되었으면 강의의 코드 블록중 하나를 아래 단계를 따라 로컬에"
-"서 실행할 수 있습니다:"
+"이 버전보다 더 최신의 버전이어도 상관 없습니다. 러스트는 하위 호환성을 지원합"
+"니다."
 
-#: src/cargo/running-locally.md:18
+#: src/cargo/running-locally.md:17
+msgid ""
+"With this in place, follow these steps to build a Rust binary from one of "
+"the examples in this training:"
+msgstr ""
+"정상적으로 설치가 되었으면, 강의 예제중 하나를 러스트 바이너리로 빌드해 봅시"
+"다:"
+
+#: src/cargo/running-locally.md:20
 msgid "Click the \"Copy to clipboard\" button on the example you want to copy."
 msgstr "예시 블록에 있는 \"Copy to clipboard\" 버튼을 클릭해서 복사합니다."
 
-#: src/cargo/running-locally.md:20
+#: src/cargo/running-locally.md:22
 msgid ""
 "Use `cargo new exercise` to create a new `exercise/` directory for your code:"
 msgstr ""
 "터미널에서 `cargo new exercise`를 입력해서 새로운 `exercise/` 폴더를 만듭니"
 "다:"
 
-#: src/cargo/running-locally.md:22
+#: src/cargo/running-locally.md:24
 msgid ""
 "```shell\n"
 "$ cargo new exercise\n"
@@ -1772,12 +1983,12 @@ msgstr ""
 "     Created binary (application) `exercise` package\n"
 "```"
 
-#: src/cargo/running-locally.md:27
+#: src/cargo/running-locally.md:29
 msgid ""
 "Navigate into `exercise/` and use `cargo run` to build and run your binary:"
 msgstr "`exercise/` 폴더로 이동한 후, `cargo run` 커맨드로 코드를 실행합니다:"
 
-#: src/cargo/running-locally.md:29
+#: src/cargo/running-locally.md:31
 msgid ""
 "```shell\n"
 "$ cd exercise\n"
@@ -1797,7 +2008,7 @@ msgstr ""
 "Hello, world!\n"
 "```"
 
-#: src/cargo/running-locally.md:38
+#: src/cargo/running-locally.md:40
 msgid ""
 "Replace the boiler-plate code in `src/main.rs` with your own code. For "
 "example, using the example on the previous page, make `src/main.rs` look like"
@@ -1805,7 +2016,7 @@ msgstr ""
 "`src/main.rs`에 코드를 작성합니다. 예를 들어 이전 페이지의 소스를 아래와 같"
 "이 `src/main.rs`에 작성합니다"
 
-#: src/cargo/running-locally.md:41
+#: src/cargo/running-locally.md:43
 msgid ""
 "```rust\n"
 "fn main() {\n"
@@ -1819,11 +2030,11 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/cargo/running-locally.md:47
+#: src/cargo/running-locally.md:49
 msgid "Use `cargo run` to build and run your updated binary:"
 msgstr "`cargo run`커맨드로 소스를 빌드하고 실행합니다:"
 
-#: src/cargo/running-locally.md:49
+#: src/cargo/running-locally.md:51
 msgid ""
 "```shell\n"
 "$ cargo run\n"
@@ -1841,7 +2052,7 @@ msgstr ""
 "Edit me!\n"
 "```"
 
-#: src/cargo/running-locally.md:57
+#: src/cargo/running-locally.md:59
 msgid ""
 "Use `cargo check` to quickly check your project for errors, use `cargo "
 "build` to compile it without running it. You will find the output in `target/"
@@ -1853,7 +2064,7 @@ msgstr ""
 "있습니다. `cargo build --release`커맨드는 릴리즈 버전용 최적화를 켜서 컴파일"
 "하며 `target/release/`폴더에서 확인 할 수 있습니다."
 
-#: src/cargo/running-locally.md:62
+#: src/cargo/running-locally.md:64
 msgid ""
 "You can add dependencies for your project by editing `Cargo.toml`. When you "
 "run `cargo` commands, it will automatically download and compile missing "
@@ -1862,7 +2073,7 @@ msgstr ""
 "`Cargo.toml`파일에는 의존성 패키지를 추가할 수 있습니다. `cargo`커맨드를 실행"
 "하면 자동으로 의존성 패키지를 다운로드하고 컴파일 까지 해 줍니다."
 
-#: src/cargo/running-locally.md:70
+#: src/cargo/running-locally.md:72
 msgid ""
 "Try to encourage the class participants to install Cargo and use a local "
 "editor. It will make their life easier since they will have a normal "
@@ -1878,7 +2089,7 @@ msgstr "1일차 개요"
 
 #: src/welcome-day-1.md:3
 msgid ""
-"This is the first day of Comprehensive Rust. We will cover a lot of ground "
+"This is the first day of Rust Fundamentals. We will cover a lot of ground "
 "today:"
 msgstr "강의 첫 날입니다. 오늘 배울 것이 참 많습니다:"
 
@@ -1916,14 +2127,15 @@ msgstr "궁금한 점이 있으면 주저하지 말고 질문 해야 합니다."
 msgid ""
 "The class is meant to be interactive and discussions are very much "
 "encouraged!"
-msgstr "이 수업은 상호작용이 중요하고 토론을 권장합니다."
+msgstr "이 수업은 상호작용이 요합니다. 토론을 망설이지 마세요!"
 
 #: src/welcome-day-1.md:20
 msgid ""
 "As an instructor, you should try to keep the discussions relevant, i.e., "
-"keep the related to how Rust does things vs some other language. It can be "
-"hard to find the right balance, but err on the side of allowing discussions "
-"since they engage people much more than one-way communication."
+"keep the discussions related to how Rust does things vs some other "
+"language.  It can be hard to find the right balance, but err on the side of "
+"allowing  discussions since they engage people much more than one-way "
+"communication."
 msgstr ""
 "강사로서 토론이 옆길로 새지 않게 주의하세요. 예를 들어 러스트와 다른 언어들"
 "을 비교한다든지 하는 것은 좋습니다. 적절한 균형을 찾기 애매한 경우라면 토론"
@@ -1989,7 +2201,7 @@ msgstr ""
 
 #: src/welcome-day-1/what-is-rust.md:5
 msgid "Rust is a statically compiled language in a similar role as C++"
-msgstr "러스트는 C++와 유사한 정적 컴파일 언어입니다."
+msgstr "러스트는 C++와 유사한 정적 컴파일 언어입니다"
 
 #: src/welcome-day-1/what-is-rust.md:6
 msgid "`rustc` uses LLVM as its backend."
@@ -1999,7 +2211,7 @@ msgstr "`rustc`는 LLVM을 백엔드로 사용합니다."
 msgid ""
 "Rust supports many [platforms and architectures](https://doc.rust-lang.org/"
 "nightly/rustc/platform-support.html):"
-msgstr "러스트는 다양한 플랫폼과 아키텍쳐를 지원합니다."
+msgstr "러스트는 다양한 플랫폼과 아키텍쳐를 지원합니다:"
 
 #: src/welcome-day-1/what-is-rust.md:9
 msgid "x86, ARM, WebAssembly, ..."
@@ -2019,19 +2231,19 @@ msgstr "펌웨어와 부트로더(임베디드)"
 
 #: src/welcome-day-1/what-is-rust.md:13
 msgid "smart displays,"
-msgstr "스마트 디스플레이"
+msgstr "스마트 디스플레이,"
 
 #: src/welcome-day-1/what-is-rust.md:14
 msgid "mobile phones,"
-msgstr "스마트폰"
+msgstr "스마트폰,"
 
 #: src/welcome-day-1/what-is-rust.md:15
 msgid "desktops,"
-msgstr "데스크탑"
+msgstr "데스크탑,"
 
 #: src/welcome-day-1/what-is-rust.md:16
 msgid "servers."
-msgstr "서버"
+msgstr "서버."
 
 #: src/welcome-day-1/what-is-rust.md:21
 msgid "Rust fits in the same area as C++:"
@@ -2043,11 +2255,12 @@ msgstr "높은 유연성."
 
 #: src/welcome-day-1/what-is-rust.md:24
 msgid "High level of control."
-msgstr "높은 레벨 수준의 제어."
+msgstr "높은 수준의 제어."
 
 #: src/welcome-day-1/what-is-rust.md:25
-msgid "Can be scaled down to very constrained devices like mobile phones."
-msgstr "휴대폰과 같은 매우 제한된 장치로 스케일 다운 가능."
+msgid ""
+"Can be scaled down to very constrained devices such as microcontrollers."
+msgstr "마이크로컨트롤러 같은 매우 제한된 장치로 스케일 다운 가능."
 
 #: src/welcome-day-1/what-is-rust.md:26
 msgid "Has no runtime or garbage collection."
@@ -2066,12 +2279,17 @@ msgstr ""
 
 #: src/hello-world.md:6
 msgid ""
-"```rust\n"
+"```rust,editable\n"
 "fn main() {\n"
 "    println!(\"Hello 🌍!\");\n"
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    println!(\"Hello 🌍!\");\n"
+"}\n"
+"```"
 
 #: src/hello-world.md:12
 msgid "What you see:"
@@ -2104,21 +2322,20 @@ msgstr ""
 #: src/hello-world.md:22
 msgid ""
 "This slide tries to make the students comfortable with Rust code. They will "
-"see a ton of it over the next four days so we start small with something "
+"see a ton of it over the next three days so we start small with something "
 "familiar."
 msgstr ""
-"이 슬라이드는 학생들이 러스트 코드에 익숙해지기 위해 작성되었습니다. 앞으로 4"
+"이 슬라이드는 학생들이 러스트 코드에 익숙해지기 위해 작성되었습니다. 앞으로 3"
 "일 동안 많은 코드를 접할 것이기 때문에 우선 친숙한 코드부터 시작합니다."
 
 #: src/hello-world.md:27
 msgid ""
 "Rust is very much like other languages in the C/C++/Java tradition. It is "
-"imperative (not functional) and it doesn't try to reinvent things unless "
-"absolutely necessary."
+"imperative and it doesn't try to reinvent things unless absolutely necessary."
 msgstr ""
 "러스트는 C/C++/Java와 같은 전통적인 다른 언어와 매우 유사합니다. 러스트는 절"
-"차적(함수형 아님) 언어입니다. 정말로 필요한 경우가 아니라면, 러스트는 이미 존"
-"재하는 것을 새로 구현하려고 하지 않습니다."
+"차적 언어입니다. 정말로 필요한 경우가 아니라면, 러스트는 이미 존재하는 것을 "
+"새로 구현하려고 하지 않습니다."
 
 #: src/hello-world.md:31
 msgid "Rust is modern with full support for things like Unicode."
@@ -2136,13 +2353,26 @@ msgstr ""
 msgid ""
 "Macros being 'hygienic' means they don't accidentally capture identifiers "
 "from the scope they are used in. Rust macros are actually only [partially "
-"hygenic](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html)."
+"hygienic](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene."
+"html)."
 msgstr ""
 "똑똑한 매크로(hygienic macro)는 매크로가 사용되는 스코프에서 의도치 않게 변수"
 "를 가로채지 않습니다. 사실 러스트 매크로는 완전히 hygenic하지는 않습니다. [링"
 "크](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html)를 참"
 "고하세요."
 
+#: src/hello-world.md:40
+msgid ""
+"Rust is multi-paradigm. For example, it has powerful [object-oriented "
+"programming features](https://doc.rust-lang.org/book/ch17-00-oop.html), and, "
+"while it is not a functional language, it includes a range of [functional "
+"concepts](https://doc.rust-lang.org/book/ch13-00-functional-features.html)."
+msgstr ""
+"러스트는 멀티 패러다임 언어입니다. 예를 들어 강력한 [객체 지향 프로그래밍 기"
+"능](https://doc.rust-lang.org/book/ch17-00-oop.html)을 지원하기도 하며, 함수"
+"형 언어로 분류되지는 않지만 폭넓은 범위의 [함수형 컨셉](https://doc.rust-"
+"lang.org/book/ch13-00-functional-features.html)을 지원합니다."
+
 #: src/hello-world/small-example.md:3
 msgid "Here is a small example program in Rust:"
 msgstr "러스트로 작성된 작은 예제입니다:"
@@ -2231,6 +2461,14 @@ msgstr ""
 "맷팅 언어의 문법을 알기 위해 `std::fmt`를 검색해야 한다는 것을 가르치세요.학"
 "생들이 표준 라이브러리의 검색 기능에 익숙해 지도록 하는 것이 중요합니다."
 
+#: src/hello-world/small-example.md:44
+msgid ""
+"In a shell `rustup doc std::fmt` will open a browser on the local std::fmt "
+"documentation"
+msgstr ""
+"쉘에서  `rustup doc std::fmt`를 수행하면 로컬 브라우저로 `std:fmt`에 대한 문"
+"서를 보여줍니다"
+
 #: src/why-rust.md:3
 msgid "Some unique selling points of Rust:"
 msgstr "러스트만의 독특한 세일즈 포인트(장점):"
@@ -2323,13 +2561,13 @@ msgstr ""
 
 #: src/why-rust/compile-time.md:19
 msgid ""
-"You can for use [`Box::leak`](https://doc.rust-lang.org/std/boxed/struct.Box."
+"You can use [`Box::leak`](https://doc.rust-lang.org/std/boxed/struct.Box."
 "html#method.leak) to leak a pointer. A use of this could be to get runtime-"
 "initialized and runtime-sized static variables"
 msgstr ""
 "[`Box::leak`](https://doc.rust-lang.org/std/boxed/struct.Box.html#method."
 "leak)을 이용하여 포인터를 의도적으로 누출시킬 수 있습니다. 이를 이용해서 런타"
-"임이 생성하고 런타임이 크기를 정한 정적 변수를 가져올 수 있습니다."
+"임이 생성하고 런타임이 크기를 정한 정적 변수를 가져올 수 있습니다"
 
 #: src/why-rust/compile-time.md:21
 msgid ""
@@ -2371,25 +2609,29 @@ msgstr "런타임 시 정의되지 않음(undefined) 동작 없음:"
 
 #: src/why-rust/runtime.md:5
 msgid "Array access is bounds checked."
-msgstr "배열 접근시 경계 체크"
+msgstr "배열 접근시 경계 체크."
 
 #: src/why-rust/runtime.md:6
-msgid "Integer overflow is defined."
+msgid "Integer overflow is defined (panic or wrap-around)."
 msgstr "정수형 타입의 변수에서 오버플로우 발생시 동작이 잘 정의되어있습니다."
 
 #: src/why-rust/runtime.md:12
 msgid ""
-"Integer overflow is defined via a compile-time flag. The options are either "
-"a panic (a controlled crash of the program) or wrap-around semantics. By "
-"default, you get panics in debug mode (`cargo build`) and wrap-around in "
-"release mode (`cargo build --release`)."
+"Integer overflow is defined via the [`overflow-checks`](https://doc.rust-"
+"lang.org/rustc/codegen-options/index.html#overflow-checks) compile-time "
+"flag. If enabled, the program will panic (a controlled crash of the "
+"program), otherwise you get wrap-around semantics. By default, you get "
+"panics in debug mode (`cargo build`) and wrap-around in release mode (`cargo "
+"build --release`)."
 msgstr ""
-"정수형 오버플로우는 컴파일 타임 플레그를 통해 정의됩니다. 옵션은 패닉(프로그"
-"램 크레시) 혹은 올림(wrap-around)입니다. 기본적으로 디버그 모드(`cargo "
-"build`)에서는 패닉이, 릴리즈 모드(`cargo build --release`)에서는 wrap-around"
-"가 발생합니다."
+"정수형 오버플로우는 [`overflow-checks`](https://doc.rust-lang.org/rustc/"
+"codegen-options/index.html#overflow-checks) 컴파일 타임 플래그를 통해 정의됩"
+"니다. 이 플래그가 켜지면, 프로그램은 정수형 오버플로우 발생시 panic (프로그램"
+"을 크래시 시키는 잘 정의된 방법) 합니다. 이 플래그가 꺼지면, 오버플로우는 "
+"wrap-around 가 됩니다. 기본적으로 디버그 모드(`cargo build`)에서는 패닉이, 릴"
+"리즈 모드(`cargo build --release`)에서는 wrap-around가 발생합니다."
 
-#: src/why-rust/runtime.md:17
+#: src/why-rust/runtime.md:18
 msgid ""
 "Bounds checking cannot be disabled with a compiler flag. It can also not be "
 "disabled directly with the `unsafe` keyword. However, `unsafe` allows you to "
@@ -2401,37 +2643,29 @@ msgstr ""
 "같은 함수는 경계 검사를 수행하지 않습니다."
 
 #: src/why-rust/modern.md:3
-msgid "Rust is built with all the experience gained in the last 40 years."
+msgid "Rust is built with all the experience gained in the last decades."
 msgstr ""
-"러스트는 지난 40년간의 모든 (프로그래밍 언어들의) 경험으로 만들어졌습니다."
+"러스트는 지난 수십년간의 모든 (프로그래밍 언어들의) 경험으로 만들어졌습니다."
 
 #: src/why-rust/modern.md:5
 msgid "Language Features"
 msgstr "언어적 특징"
 
 #: src/why-rust/modern.md:7
-#, fuzzy
 msgid "Enums and pattern matching."
 msgstr "열거형과 패턴 매칭."
 
 #: src/why-rust/modern.md:8
-#, fuzzy
 msgid "Generics."
 msgstr "제네릭."
 
 #: src/why-rust/modern.md:9
-#, fuzzy
 msgid "No overhead FFI."
 msgstr "FFI 런타임 오버헤드 없음."
 
 #: src/why-rust/modern.md:10
-#, fuzzy
 msgid "Zero-cost abstractions."
-msgstr ""
-"_역주: FFI: Foreign Function Interface. 타 언어 코드를 호출하기 위한 인터페이"
-"스_\n"
-"\n"
-"제로 코스트 추상화."
+msgstr "비용이 들지 않는 추상화."
 
 #: src/why-rust/modern.md:12
 msgid "Tooling"
@@ -2574,12 +2808,13 @@ msgid "Variable assignment is done with `=`, comparison is done with `==`."
 msgstr "변수 할당은 `=`, 비교는 `==`를 사용합니다."
 
 #: src/basic-syntax/scalar-types.md:3 src/basic-syntax/compound-types.md:3
+#: src/exercises/day-3/safe-ffi-wrapper.md:16
 msgid "Types"
 msgstr "타입"
 
 #: src/basic-syntax/scalar-types.md:3 src/basic-syntax/compound-types.md:3
 msgid "Literals"
-msgstr "스칼라 리터럴 값"
+msgstr "리터럴 값"
 
 #: src/basic-syntax/scalar-types.md:5
 msgid "Signed integers"
@@ -2590,8 +2825,8 @@ msgid "`i8`, `i16`, `i32`, `i64`, `i128`, `isize`"
 msgstr "`i8`, `i16`, `i32`, `i64`, `i128`, `isize`"
 
 #: src/basic-syntax/scalar-types.md:5
-msgid "`-10`, `0`, `1_000`, `123i64`"
-msgstr "`-10`, `0`, `1_000`, `123i64`"
+msgid "`-10`, `0`, `1_000`, `123_i64`"
+msgstr "`-10`, `0`, `1_000`, `123_i64`"
 
 #: src/basic-syntax/scalar-types.md:6
 msgid "Unsigned integers"
@@ -2602,8 +2837,8 @@ msgid "`u8`, `u16`, `u32`, `u64`, `u128`, `usize`"
 msgstr "`u8`, `u16`, `u32`, `u64`, `u128`, `usize`"
 
 #: src/basic-syntax/scalar-types.md:6
-msgid "`0`, `123`, `10u16`"
-msgstr "`0`, `123`, `10u16`"
+msgid "`0`, `123`, `10_u16`"
+msgstr "`0`, `123`, `10_u16`"
 
 #: src/basic-syntax/scalar-types.md:7
 msgid "Floating point numbers"
@@ -2614,8 +2849,8 @@ msgid "`f32`, `f64`"
 msgstr "`f32`, `f64`"
 
 #: src/basic-syntax/scalar-types.md:7
-msgid "`3.14`, `-10.0e20`, `2f32`"
-msgstr "`3.14`, `-10.0e20`, `2f32`"
+msgid "`3.14`, `-10.0e20`, `2_f32`"
+msgstr "`3.14`, `-10.0e20`, `2_f32`"
 
 #: src/basic-syntax/scalar-types.md:8
 msgid "Strings"
@@ -2626,8 +2861,8 @@ msgid "`&str`"
 msgstr "`&str`"
 
 #: src/basic-syntax/scalar-types.md:8
-msgid "`\"foo\"`, `r#\"\\\\\"#`"
-msgstr "`\"foo\"`, `r#\"\\\\\"#`"
+msgid "`\"foo\"`, `\"two\\nlines\"`"
+msgstr "`\"foo\"`, `\"two\\nlines\"`"
 
 #: src/basic-syntax/scalar-types.md:9
 msgid "Unicode scalar values"
@@ -2642,59 +2877,96 @@ msgid "`'a'`, `'α'`, `'∞'`"
 msgstr "`'a'`, `'α'`, `'∞'`"
 
 #: src/basic-syntax/scalar-types.md:10
-msgid "Byte strings"
-msgstr "바이트 문자"
-
-#: src/basic-syntax/scalar-types.md:10
-msgid "`&[u8]`"
-msgstr "`&[u8]`"
-
-#: src/basic-syntax/scalar-types.md:10
-msgid "`b\"abc\"`, `br#\" \" \"#`"
-msgstr "`b\"abc\"`, `br#\" \" \"#`"
-
-#: src/basic-syntax/scalar-types.md:11
 msgid "Booleans"
 msgstr "불리언"
 
-#: src/basic-syntax/scalar-types.md:11
+#: src/basic-syntax/scalar-types.md:10
 msgid "`bool`"
 msgstr "`bool`"
 
-#: src/basic-syntax/scalar-types.md:11
+#: src/basic-syntax/scalar-types.md:10
 msgid "`true`, `false`"
 msgstr "`true`, `false`"
 
-#: src/basic-syntax/scalar-types.md:13
+#: src/basic-syntax/scalar-types.md:12
 msgid "The types have widths as follows:"
 msgstr "각 타입의 크기는 다음과 같습니다:"
 
-#: src/basic-syntax/scalar-types.md:15
-#, fuzzy
+#: src/basic-syntax/scalar-types.md:14
 msgid "`iN`, `uN`, and `fN` are _N_ bits wide,"
-msgstr ""
-"정수(`i`) 및 부동소수형(`f`)은 뒤의 숫자와 같은 비트 수 입니다. (`i8` = 8비"
-"트)"
+msgstr "`iN`, `uN`, `fN`은 모두 _N_비트 입니다."
+
+#: src/basic-syntax/scalar-types.md:15
+msgid "`isize` and `usize` are the width of a pointer,"
+msgstr "`isize` 와 `usize` 는 포인터와 같은 크기입니다,"
 
 #: src/basic-syntax/scalar-types.md:16
-#, fuzzy
-msgid "`isize` and `usize` are the width of a pointer,"
-msgstr "`isize` 와 `usize` 는 포인터와 같은 크기입니다."
+msgid "`char` is 32 bits wide,"
+msgstr "`char` 32 비트 입니다,"
 
 #: src/basic-syntax/scalar-types.md:17
-#, fuzzy
-msgid "`char` is 32 bit wide,"
-msgstr ""
-"_역주: 32 비트 시스템에서는 32 비트, 64 비트 시스템에서는 64 비트. C의 `int`"
-"와 같음._"
+msgid "`bool` is 8 bits wide."
+msgstr "`bool`은 8 비트 입니다."
 
-#: src/basic-syntax/scalar-types.md:18
-#, fuzzy
-msgid "`bool` is 8 bit wide."
+#: src/basic-syntax/scalar-types.md:21
+msgid "There are a few syntaxes which are not shown above:"
+msgstr "위에 표시되지 않은 몇 가지 문법이 있습니다:"
+
+#: src/basic-syntax/scalar-types.md:23
+msgid ""
+"Raw strings allow you to create a `&str` value with escapes disabled: "
+"`r\"\\n\" == \"\\\\n\"`. You can embed double-quotes by using an equal "
+"amount of `#` on either side of the quotes:"
 msgstr ""
-"`char` 32 비트 입니다.\n"
-"\n"
-"`bool`은 8 비트 입니다."
+"Raw strings allow you to create a `&str` value with escapes disabled: "
+"`r\"\\n\" == \"\\\\n\"`. You can embed double-quotes by using an equal "
+"amount of `#` on either side of the quotes:"
+
+#: src/basic-syntax/scalar-types.md:27
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    println!(r#\"<a href=\"link.html\">link</a>\"#);\n"
+"    println!(\"<a href=\\\"link.html\\\">link</a>\");\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    println!(r#\"<a href=\"link.html\">link</a>\"#);\n"
+"    println!(\"<a href=\\\"link.html\\\">link</a>\");\n"
+"}\n"
+"```"
+
+#: src/basic-syntax/scalar-types.md:34
+msgid "Byte strings allow you to create a `&[u8]` value directly:"
+msgstr "Byte strings allow you to create a `&[u8]` value directly:"
+
+#: src/basic-syntax/scalar-types.md:36
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    println!(\"{:?}\", b\"abc\");\n"
+"    println!(\"{:?}\", &[97, 98, 99]);\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    println!(\"{:?}\", b\"abc\");\n"
+"    println!(\"{:?}\", &[97, 98, 99]);\n"
+"}\n"
+"```"
+
+#: src/basic-syntax/scalar-types.md:43
+msgid ""
+"All underscores in numbers can be left out, they are for legibility only. So "
+"`1_000` can be written as `1000` (or `10_00`), and `123_i64` can be written "
+"as `123i64`."
+msgstr ""
+"All underscores in numbers can be left out, they are for legibility only. So "
+"`1_000` can be written as `1000` (or `10_00`), and `123_i64` can be written "
+"as `123i64`."
 
 #: src/basic-syntax/compound-types.md:5
 msgid "Arrays"
@@ -2770,10 +3042,10 @@ msgstr "배열:"
 
 #: src/basic-syntax/compound-types.md:34
 msgid ""
-"Arrays have elements of the same type, `T`, and length, `N`, which is a "
-"compile-time constant. Note that the length of the array is _part of its "
-"type_, which means that `[u8; 3]` and `[u8; 4]` are considered two different "
-"types."
+"A value of the array type `[T; N]` holds `N` (a compile-time constant) "
+"elements of the same type `T`. Note that the length of the array is _part of "
+"its type_, which means that `[u8; 3]` and `[u8; 4]` are considered two "
+"different types."
 msgstr ""
 "배열은, 같은 타입 `T`의 값이 `N`개 있는 것입니다. 여기서 `N`은 컴파일 타임에 "
 "결정된 값이어야 합니다. 이 길이도 타입의 일부입니다. 따라서, `[u8; 3]`와 "
@@ -2828,7 +3100,7 @@ msgid ""
 msgstr ""
 "비어있는 튜플`()`은 단위 타입(unit type)이라고도 합니다. 이는 타입이면서 해"
 "당 타입의 유일하며 유효한 값입니다. 즉 타입과 값이 모두 `()`입니다. 예를 들"
-"어 함수나 식에서 반환 값이 없음을 나타낼 때 사용합니다."
+"어 함수나 식에서 반환 값이 없음을 나타낼 때 사용합니다. "
 
 #: src/basic-syntax/compound-types.md:59
 msgid ""
@@ -2887,7 +3159,7 @@ msgid ""
 msgstr ""
 "`mut`로 선언된 참조는 그 변수가 살아있는 동안 다른 값을 가질 수 있습니다."
 
-#: src/basic-syntax/references.md:24
+#: src/basic-syntax/references.md:25
 msgid ""
 "Be sure to note the difference between `let mut ref_x: &i32` and `let ref_x: "
 "&mut i32`. The first one represents a mutable reference which can be bound "
@@ -2951,10 +3223,11 @@ msgstr "슬라이스는 큰 컬랙션의 일부(혹은 전체)를 보여주는 
 msgid ""
 "```rust,editable\n"
 "fn main() {\n"
-"    let a: [i32; 6] = [10, 20, 30, 40, 50, 60];\n"
+"    let mut a: [i32; 6] = [10, 20, 30, 40, 50, 60];\n"
 "    println!(\"a: {a:?}\");\n"
 "\n"
 "    let s: &[i32] = &a[2..4];\n"
+"\n"
 "    println!(\"s: {s:?}\");\n"
 "}\n"
 "```"
@@ -2969,15 +3242,15 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/basic-syntax/slices.md:15
+#: src/basic-syntax/slices.md:16
 msgid "Slices borrow data from the sliced type."
 msgstr "슬라이스는 다른(슬라이스 된) 타입으로부터 데이터를 '빌려'옵니다."
 
-#: src/basic-syntax/slices.md:16
-msgid "Question: What happens if you modify `a[3]`?"
-msgstr "질문: `a[3]`을 수정하면 무슨 일이 있어날까요?"
+#: src/basic-syntax/slices.md:17
+msgid "Question: What happens if you modify `a[3]` right before printing `s`?"
+msgstr "질문: `s`를 출력하기 전에 `a[3]`을 수정하면 무슨 일이 있어날까요?"
 
-#: src/basic-syntax/slices.md:20
+#: src/basic-syntax/slices.md:21
 msgid ""
 "We create a slice by borrowing `a` and specifying the starting and ending "
 "indexes in brackets."
@@ -2985,7 +3258,7 @@ msgstr ""
 "슬라이스는 우선 `a`를 빌린다음, 시작과 끝 인덱스를 브래킷(`[]`)안에 지정해서 "
 "만듭니다."
 
-#: src/basic-syntax/slices.md:22
+#: src/basic-syntax/slices.md:23
 msgid ""
 "If the slice starts at index 0, Rust’s range syntax allows us to drop the "
 "starting index, meaning that `&a[0..a.len()]` and `&a[..a.len()]` are "
@@ -2994,7 +3267,7 @@ msgstr ""
 "슬라이스가 인덱스 0부터 시작한다면 시작 인덱스는 생략 가능합니다. 즉 `&a[0.."
 "a.len()]`와 `&a[..a.len()]` 는 동일합니다."
 
-#: src/basic-syntax/slices.md:24
+#: src/basic-syntax/slices.md:25
 msgid ""
 "The same is true for the last index, so `&a[2..a.len()]` and `&a[2..]` are "
 "identical."
@@ -3002,12 +3275,12 @@ msgstr ""
 "마지막 인덱스도 생략 가능합니다. 그래서 `&a[2..a.len()]` 와 `&a[2..]`는 동일"
 "합니다."
 
-#: src/basic-syntax/slices.md:26
+#: src/basic-syntax/slices.md:27
 msgid ""
 "To easily create a slice of the full array, we can therefore use `&a[..]`."
 msgstr "따라서 전체 배열에 대한 슬라이스는 `&a[..]`가 됩니다."
 
-#: src/basic-syntax/slices.md:28
+#: src/basic-syntax/slices.md:29
 msgid ""
 "`s` is a reference to a slice of `i32`s. Notice that the type of `s` "
 "(`&[i32]`) no longer mentions the array length. This allows us to perform "
@@ -3017,25 +3290,28 @@ msgstr ""
 "배열의 크기가 빠져있음에 주목하시기 바랍니다. 즉, 슬라이스를 이용하면 다양한 "
 "길이의 데이터를 다룰 수 있습니다."
 
-#: src/basic-syntax/slices.md:30
+#: src/basic-syntax/slices.md:31
 msgid ""
 "Slices always borrow from another object. In this example, `a` has to remain "
 "'alive' (in scope) for at least as long as our slice. "
 msgstr ""
 "슬라이스는 항상 다른 객체로부터 '빌려' 옵니다. 이 예시에서 객체 `a`는 슬라이"
-"스 `s`보다 더 오래 살아 있어야만 합니다."
+"스 `s`보다 더 오래 살아 있어야만 합니다. "
 
-#: src/basic-syntax/slices.md:32
+#: src/basic-syntax/slices.md:33
 msgid ""
 "The question about modifying `a[3]` can spark an interesting discussion, but "
-"the answer is that for memory safety reasons you cannot do it through `a` "
-"after you created a slice, but you can read the data from both `a` and `s` "
-"safely.  More details will be explained in the borrow checker section."
+"the answer is that for memory safety reasons you cannot do it through `a` at "
+"this point in the execution, but you can read the data from both `a` and `s` "
+"safely. It works before you created the slice, and again after the "
+"`println`, when the slice is no longer used. More details will be explained "
+"in the borrow checker section."
 msgstr ""
 "`a[3]`의 값을 바꿀 수 있냐는 질문은 좋은 질문입니다. 여기에 대한 답은 `a`와 "
 "`s`를 통해 데이터를 읽을 수는 있지만 수정할 수는 없으며, 이는 메모리 안전을 "
-"위해서라는 것입니다. 왜 그런지에 대한 좀더 구체적인 답은 빌림 검사 부분에서 "
-"자세히 설명합니다."
+"위해서라는 것입니다. 그런데, 슬라이스가 사용되지 않을 때, 즉 슬라이스를 만들"
+"기 전이나, 혹은 `println`이후에는 `a[3]`을 바꿀 수 있습니다. 왜 그런지에 대"
+"한 좀더 구체적인 답은 빌림 검사 부분에서 자세히 설명합니다."
 
 #: src/basic-syntax/string-slices.md:1
 msgid "`String` vs `str`"
@@ -3095,9 +3371,9 @@ msgid ""
 "encoded string data  stored in a block of memory. String literals "
 "(`”Hello”`), are stored in the program’s binary."
 msgstr ""
-"`&str`은 문자열 슬라이스의 불변 참조입니다. 러스트에서 문자열은 UTF-8로 인코"
-"딩된 데이터를 의미합니다. 문자열 리터럴(`\"Hello\"`)은 프로그램 바이너리에 저"
-"장됩니다."
+"`&str`은 문자열 슬라이스입니다. 문자열 슬라이스는 UTF-8로 인코딩된 문자열 데"
+"이터를 의미합니다. 문자열 리터럴(`\"Hello\"`)은 프로그램 바이너리에 저장됩니"
+"다."
 
 #: src/basic-syntax/string-slices.md:30
 msgid ""
@@ -3145,7 +3421,7 @@ msgstr ""
 "효한 문자열을 가리킨다는 점이 다릅니다. 러스트의 `String`은 C++의 `std::"
 "string` 과 대략 거의 동일합니다. (주요 차이점: 러스트의 `String`은 UTF-8 인코"
 "딩 바이트만 포함할 수 있으며 작은 문자열 최적화(small-string optimization)는 "
-"사용하지 않습니다."
+"구현하지 않습니다."
 
 #: src/basic-syntax/functions.md:3
 msgid ""
@@ -3158,59 +3434,56 @@ msgstr ""
 msgid ""
 "```rust,editable\n"
 "fn main() {\n"
-"    fizzbuzz_to(20);   // Defined below, no forward declaration needed\n"
+"    print_fizzbuzz_to(20);\n"
 "}\n"
 "\n"
-"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
-"    if rhs == 0 {\n"
-"        return false;  // Corner case, early return\n"
+"fn is_divisible(n: u32, divisor: u32) -> bool {\n"
+"    if divisor == 0 {\n"
+"        return false;\n"
 "    }\n"
-"    lhs % rhs == 0     // The last expression in a block is the return "
-"value\n"
+"    n % divisor == 0\n"
 "}\n"
 "\n"
-"fn fizzbuzz(n: u32) -> () {  // No return value means returning the unit "
-"type `()`\n"
-"    match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {\n"
-"        (true,  true)  => println!(\"fizzbuzz\"),\n"
-"        (true,  false) => println!(\"fizz\"),\n"
-"        (false, true)  => println!(\"buzz\"),\n"
-"        (false, false) => println!(\"{n}\"),\n"
+"fn fizzbuzz(n: u32) -> String {\n"
+"    let fizz = if is_divisible(n, 3) { \"fizz\" } else { \"\" };\n"
+"    let buzz = if is_divisible(n, 5) { \"buzz\" } else { \"\" };\n"
+"    if fizz.is_empty() && buzz.is_empty() {\n"
+"        return format!(\"{n}\");\n"
 "    }\n"
+"    format!(\"{fizz}{buzz}\")\n"
 "}\n"
 "\n"
-"fn fizzbuzz_to(n: u32) {  // `-> ()` is normally omitted\n"
+"fn print_fizzbuzz_to(n: u32) {\n"
 "    for i in 1..=n {\n"
-"        fizzbuzz(i);\n"
+"        println!(\"{}\", fizzbuzz(i));\n"
 "    }\n"
 "}\n"
 "```"
 msgstr ""
 "```rust,editable\n"
 "fn main() {\n"
-"    fizzbuzz_to(20);   // C/C++ 와 달리 호출부 하단에 정의해도 문제 없습니"
-"다.\n"
+"    print_fizzbuzz_to(20);\n"
 "}\n"
 "\n"
-"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
-"    if rhs == 0 {\n"
-"        return false;  // Corner case이므로 반환합니다.\n"
+"fn is_divisible(n: u32, divisor: u32) -> bool {\n"
+"    if divisor == 0 {\n"
+"        return false;\n"
 "    }\n"
-"    lhs % rhs == 0     // 마지막 표현식은 반환 값입니다.(;없음에 주목)\n"
+"    n % divisor == 0\n"
 "}\n"
 "\n"
-"fn fizzbuzz(n: u32) -> () {  // `()`는 반환값이 없다는 것을 의미합니다.\n"
-"    match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {\n"
-"        (true,  true)  => println!(\"fizzbuzz\"),\n"
-"        (true,  false) => println!(\"fizz\"),\n"
-"        (false, true)  => println!(\"buzz\"),\n"
-"        (false, false) => println!(\"{n}\"),\n"
+"fn fizzbuzz(n: u32) -> String {\n"
+"    let fizz = if is_divisible(n, 3) { \"fizz\" } else { \"\" };\n"
+"    let buzz = if is_divisible(n, 5) { \"buzz\" } else { \"\" };\n"
+"    if fizz.is_empty() && buzz.is_empty() {\n"
+"        return format!(\"{n}\");\n"
 "    }\n"
+"    format!(\"{fizz}{buzz}\")\n"
 "}\n"
 "\n"
-"fn fizzbuzz_to(n: u32) {  // `-> ()` 는 일반적으로 생략합니다.\n"
+"fn print_fizzbuzz_to(n: u32) {\n"
 "    for i in 1..=n {\n"
-"        fizzbuzz(i);\n"
+"        println!(\"{}\", fizzbuzz(i));\n"
 "    }\n"
 "}\n"
 "```"
@@ -3220,8 +3493,8 @@ msgid ""
 "We refer in `main` to a function written below. Neither forward declarations "
 "nor headers are necessary. "
 msgstr ""
-"`main` 함수에서 그 다음에 오는 함수들을 사용할 수 있습니다. 상단에 선언이나 "
-"헤더 같은건 필요 없습니다."
+"`main` 함수에서 그 다음에 오는 함수들을 사용할 수 있습니다. 미리 선언하기"
+"(forward declaration)나 헤더 같은건 필요 없습니다. "
 
 #: src/basic-syntax/functions.md:36
 msgid ""
@@ -3250,50 +3523,97 @@ msgstr ""
 
 #: src/basic-syntax/functions.md:39
 msgid ""
-"The range expression in the `for` loop in `fizzbuzz_to()` contains `=n`, "
-"which causes it to include the upper bound."
+"The range expression in the `for` loop in `print_fizzbuzz_to()` contains "
+"`=n`, which causes it to include the upper bound."
 msgstr ""
 "`fizzbuzz_to()`함수 내 `for` 반목문의 범위 표현식 중 `=n`은 n까지 포함한다는 "
 "의미입니다."
 
-#: src/basic-syntax/functions.md:40
+#: src/basic-syntax/rustdoc.md:3
 msgid ""
-"The `match` expression in `fizzbuzz()` is doing a lot of work. It is "
-"expanded below to show what is happening."
-msgstr ""
-"`fizzbuzz()`함수의 `match` 표현식은 많은 일을 합니다. 무슨 일이 일어나는지 조"
-"금 더 이해하기 쉽도록 아래 코드를 확인하시기 바랍니다."
+"All language items in Rust can be documented using special `///` syntax."
+msgstr "Rust의 아이템(item)은 `///` 문법을 사용하여 문서화할 수 있습니다."
 
-#: src/basic-syntax/functions.md:42
-msgid "(Type annotations added for clarity, but they can be elided.)"
-msgstr "(명확한 설명을 위해 타입이 명시적으로 선언 되었지만 생략 가능합니다.)"
-
-#: src/basic-syntax/functions.md:44
+#: src/basic-syntax/rustdoc.md:5
 msgid ""
-"```rust,ignore\n"
-"let by_3: bool = is_divisible_by(n, 3);\n"
-"let by_5: bool = is_divisible_by(n, 5);\n"
-"let by_35: (bool, bool) = (by_3, by_5);\n"
-"match by_35 {\n"
-"  // ...\n"
+"```rust,editable\n"
+"/// Determine whether the first argument is divisible by the second "
+"argument.\n"
+"///\n"
+"/// If the second argument is zero, the result is false.\n"
+"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
+"    if rhs == 0 {\n"
+"        return false;  // Corner case, early return\n"
+"    }\n"
+"    lhs % rhs == 0     // The last expression in a block is the return "
+"value\n"
+"}\n"
 "```"
 msgstr ""
-"```rust,ignore\n"
-"let by_3: bool = is_divisible_by(n, 3);\n"
-"let by_5: bool = is_divisible_by(n, 5);\n"
-"let by_35: (bool, bool) = (by_3, by_5);\n"
-"match by_35 {\n"
-"  // ...\n"
+"```rust,editable\n"
+"/// 첫 번째 인수가 두 번째 인수로 나눠질 수 있는지 결정합니다.\n"
+"///\n"
+"/// 두 번째 인수가 0이면 결과는 false입니다.\n"
+"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
+"    if rhs == 0 {\n"
+"        return false;  // Corner case, early return\n"
+"    }\n"
+"    lhs % rhs == 0     // 블록 안의 마지막 표현식은 반환값입니다\n"
+"}\n"
 "```"
 
+#: src/basic-syntax/rustdoc.md:17
+msgid ""
+"The contents are treated as Markdown. All published Rust library crates are "
+"automatically documented at [`docs.rs`](https://docs.rs) using the [rustdoc]"
+"(https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It is "
+"idiomatic to document all public items in an API using this pattern."
+msgstr ""
+"콘텐츠는 마크다운으로 처리됩니다. 게시된 모든 Rust 라이브러리 크레이트는 "
+"[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) 도구를 사용"
+"하여 [`docs.rs`](https://docs.rs)에 자동으로 문서화됩니다. 일반적으로 API의 "
+"모든 공개 항목은 이 패턴을 사용하여 문서화됩니다."
+
+#: src/basic-syntax/rustdoc.md:24
+msgid ""
+"Show students the generated docs for the `rand` crate at [`docs.rs/rand`]"
+"(https://docs.rs/rand)."
+msgstr ""
+"[`docs.rs/rand`](https://docs.rs/rand)에서 `rand` 크레이트용으로 생성된 문서"
+"를 보여줍니다."
+
+#: src/basic-syntax/rustdoc.md:27
+msgid ""
+"This course does not include rustdoc on slides, just to save space, but in "
+"real code they should be present."
+msgstr ""
+"이 슬라이드의 예제 코드는 문서화 주석이 생략되어 있지만, 실제 코드라면 문서"
+"화 주석을 반드시 써야 합니다."
+
+#: src/basic-syntax/rustdoc.md:30
+msgid ""
+"Inner doc comments are discussed later (in the page on modules) and need not "
+"be addressed here."
+msgstr ""
+"문서 내부 주석 모듈 페이지 뒷부분에서 다루며 여기서 다루지 않아도 됩니다."
+
+#: src/basic-syntax/rustdoc.md:33
+msgid ""
+"Rustdoc comments can contain code snippets that we can run and test using "
+"`cargo test`. We will discuss these tests in the [Testing section](../"
+"testing/doc-tests.html)."
+msgstr ""
+"문서화 주석은 코드를 포함할 수도 있으며, 이 코드는 `cargo test`를 통해 테스트"
+"로 동작할 수도 있습니다. [테스트](../testing/doc-tests.html)에서 더 자세히 다"
+"루겠습니다."
+
 #: src/basic-syntax/methods.md:3
 msgid ""
-"Rust has methods, they are simply functions that are associated with a "
-"particular type. The first argument of a method is an instance of the type "
-"it is associated with:"
+"Methods are functions associated with a type. The `self` argument of a "
+"method is an instance of the type it is associated with:"
 msgstr ""
-"러스트의 메서드는 특정 타입과 연결된 함수입니다. 메서드의 첫번째 인자의 타입"
-"이 바로 그 메서드가 연결된 타입입니다:"
+"메서드는 특정 타입과 연결된 함수입니다. 메서드의 `self` 인자가 그 메서드가 연"
+"결된 인스턴스의 타입입니다:"
 
 #: src/basic-syntax/methods.md:6
 msgid ""
@@ -3351,6 +3671,45 @@ msgid ""
 "class."
 msgstr "오늘과 내일 강의에서 더 많은 메서드 사용법을 다룰 것입니다."
 
+#: src/basic-syntax/methods.md:34
+msgid "Add a static method called `Rectangle::new` and call this from `main`:"
+msgstr "`Rectangle::new` 생성자를 추가하고 이를 `main`에서 호출합니다:"
+
+#: src/basic-syntax/methods.md:36
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn new(width: u32, height: u32) -> Rectangle {\n"
+"    Rectangle { width, height }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"fn new(width: u32, height: u32) -> Rectangle {\n"
+"    Rectangle { width, height }\n"
+"}\n"
+"```"
+
+#: src/basic-syntax/methods.md:42
+msgid ""
+"While _technically_, Rust does not have custom constructors, static methods "
+"are commonly used to initialize structs (but don't have to). The actual "
+"constructor, `Rectangle { width, height }`, could be called directly. See "
+"the [Rustnomicon](https://doc.rust-lang.org/nomicon/constructors.html)."
+msgstr ""
+"\\_기술적_으로 이야기 하자면, 러스트는 커스텀 생성자를 지원하지 않습니다. 정"
+"적 메소드를 사용하는 것이 구조체를 초기화 하는 일반적인 방법입니다 (물론 이것"
+"이 강제되지는 않습니다). 진짜 생성자인 `Rectangle { width, height }`를 직접 "
+"호출할 수도 있습니다. 자세한 내용은 [Rustnomicon](https://doc.rust-lang.org/"
+"nomicon/constructors.html)을 참조하세요."
+
+#: src/basic-syntax/methods.md:45
+msgid ""
+"Add a `Rectangle::square(width: u32)` constructor to illustrate that such "
+"static methods can take arbitrary parameters."
+msgstr ""
+"`Rectangle::square(width: u32)` 생성자를 추가하여 생성자가 임의의 매개변수를 "
+"사용할 수 있음을 보입시다."
+
 #: src/basic-syntax/functions-interlude.md:1
 msgid "Function Overloading"
 msgstr "(함수) 오버로딩"
@@ -3361,7 +3720,7 @@ msgstr "오버로딩은 지원되지 않습니다:"
 
 #: src/basic-syntax/functions-interlude.md:5
 msgid "Each function has a single implementation:"
-msgstr "개별함수는 단일 구현만 갖습니다."
+msgstr "개별함수는 단일 구현만 갖습니다:"
 
 #: src/basic-syntax/functions-interlude.md:6
 msgid "Always takes a fixed number of parameters."
@@ -3373,11 +3732,11 @@ msgstr "파라매터들의 타입은 항상 고정되어 있습니다."
 
 #: src/basic-syntax/functions-interlude.md:8
 msgid "Default values are not supported:"
-msgstr "파라매터의 기본 값은 지원되지 않습니다."
+msgstr "파라매터의 기본 값은 지원되지 않습니다:"
 
 #: src/basic-syntax/functions-interlude.md:9
 msgid "All call sites have the same number of arguments."
-msgstr "모든 호출부에서는 동일한 수의 인자를 설정해야합니다. "
+msgstr "모든 호출부에서는 동일한 수의 인자를 설정해야합니다."
 
 #: src/basic-syntax/functions-interlude.md:10
 msgid "Macros are sometimes used as an alternative."
@@ -3464,7 +3823,10 @@ msgstr ""
 
 #: src/exercises/day-1/morning.md:22 src/exercises/day-1/afternoon.md:11
 #: src/exercises/day-2/morning.md:11 src/exercises/day-2/afternoon.md:7
-#: src/exercises/day-3/morning.md:7 src/exercises/day-4/morning.md:12
+#: src/exercises/day-3/morning.md:7 src/exercises/bare-metal/morning.md:7
+#: src/exercises/bare-metal/afternoon.md:7
+#: src/exercises/concurrency/morning.md:12
+#: src/exercises/concurrency/afternoon.md:13
 msgid ""
 "After looking at the exercises, you can look at the \\[solutions\\] provided."
 msgstr ""
@@ -3495,6 +3857,18 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable,compile_fail\n"
+"fn multiply(x: i16, y: i16) -> i16 {\n"
+"    x * y\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let x: i8 = 15;\n"
+"    let y: i16 = 1000;\n"
+"\n"
+"    println!(\"{x} * {y} = {}\", multiply(x, y));\n"
+"}\n"
+"```"
 
 #: src/exercises/day-1/implicit-conversions.md:19
 msgid ""
@@ -3571,6 +3945,9 @@ msgid ""
 "let array = [10, 20, 30];\n"
 "```"
 msgstr ""
+"```rust\n"
+"let array = [10, 20, 30];\n"
+"```"
 
 #: src/exercises/day-1/for-loops.md:9
 msgid ""
@@ -3587,6 +3964,12 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let array = [10, 20, 30];\n"
+"    println!(\"array: {array:?}\");\n"
+"}\n"
+"```"
 
 #: src/exercises/day-1/for-loops.md:18
 msgid ""
@@ -3613,6 +3996,22 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let array = [10, 20, 30];\n"
+"    print!(\"Iterating over array:\");\n"
+"    for n in array {\n"
+"        print!(\" {n}\");\n"
+"    }\n"
+"    println!();\n"
+"\n"
+"    print!(\"Iterating over range:\");\n"
+"    for i in 0..3 {\n"
+"        print!(\" {}\", array[i]);\n"
+"    }\n"
+"    println!();\n"
+"}\n"
+"```"
 
 #: src/exercises/day-1/for-loops.md:38
 msgid ""
@@ -3631,6 +4030,11 @@ msgid ""
 "           ⎝⎣7 8 9⎦⎠      ⎣3 6 9⎦\n"
 "```"
 msgstr ""
+"```bob\n"
+"           ⎛⎡1 2 3⎤⎞      ⎡1 4 7⎤\n"
+"\"transpose\"⎜⎢4 5 6⎥⎟  \"==\"⎢2 5 8⎥\n"
+"           ⎝⎣7 8 9⎦⎠      ⎣3 6 9⎦\n"
+"```"
 
 #: src/exercises/day-1/for-loops.md:47
 msgid "Hard-code both functions to operate on 3 × 3 matrices."
@@ -3767,14 +4171,6 @@ msgstr ""
 "타입 추론에 덕분에 `i32`는 생략 가능합니다. 강의가 진행될 수록 생략 가능한 부"
 "분은 점점 생략할 것입니다."
 
-#: src/basic-syntax/variables.md:18
-msgid ""
-"Note that since `println!` is a macro, `x` is not moved, even using the "
-"function like syntax of `println!(\"x: {}\", x)`"
-msgstr ""
-"`println!(\"x: {}\", x)`는 함수 호출 처럼 보이지만 실은 매크로 호출이며 `x`"
-"는 이동되지 않습니다."
-
 #: src/basic-syntax/type-inference.md:3
 msgid "Rust will look at how the variable is _used_ to determine the type:"
 msgstr "러스트는 변수가 어떻게 사용되는지를 보고 그 변수의 타입을 추론합니다:"
@@ -3879,30 +4275,44 @@ msgstr ""
 #: src/basic-syntax/type-inference.md:46
 msgid ""
 "[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator."
-"html#method.collect) relies on `FromIterator`, which [`HashSet`](https://doc."
-"rust-lang.org/std/iter/trait.FromIterator.html) implements."
+"html#method.collect) relies on [`FromIterator`](https://doc.rust-lang.org/"
+"std/iter/trait.FromIterator.html), which [`HashSet`](https://doc.rust-lang."
+"org/std/collections/struct.HashSet.html#impl-FromIterator%3CT%3E-for-"
+"HashSet%3CT,+S%3E) implements."
 msgstr ""
 "[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator."
-"html#method.collect)는 [`HashSet`](https://doc.rust-lang.org/std/iter/trait."
-"FromIterator.html)을 구현한 `FromIterator`에 의존합니다."
+"html#method.collect)는 [`HashSet`](https://doc.rust-lang.org/std/collections/"
+"struct.HashSet.html#impl-FromIterator%3CT%3E-for-HashSet%3CT,+S%3E)을 구현한 "
+"[`FromIterator`](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)"
+"에 의존합니다."
 
 #: src/basic-syntax/static-and-const.md:1
 msgid "Static and Constant Variables"
 msgstr "정적변수(static)과 상수(const)"
 
 #: src/basic-syntax/static-and-const.md:3
-msgid "Global state is managed with static and constant variables."
-msgstr "프로그램의 글로벌 상태는 결국 정적 변수와 상수로 표현됩니다."
+msgid ""
+"Static and constant variables are two different ways to create globally-"
+"scoped values that cannot be moved or reallocated during the execution of "
+"the program. "
+msgstr ""
+"정적 변수와 상수는 전역 스코프에서 값을 생성하는 두 가지 방법입니다. 전역 스"
+"코프에 생성된 값은 프로그램 수행 도중에 다른 값으로 이동되지 않으며, 메모리 "
+"상에서 그 위치가 변하지 않습니다. "
 
-#: src/basic-syntax/static-and-const.md:5
+#: src/basic-syntax/static-and-const.md:6
 msgid "`const`"
 msgstr "상수(`const`)"
 
-#: src/basic-syntax/static-and-const.md:7
-msgid "You can declare compile-time constants:"
-msgstr "컴파일 시 값이 정해지는 상수를 선언할 수 있습니다:"
+#: src/basic-syntax/static-and-const.md:8
+msgid ""
+"Constant variables are evaluated at compile time and their values are "
+"inlined wherever they are used:"
+msgstr ""
+"상수는 컴파일 할 때 그 값이 정해집니다. 그리고 그 값은 그 상수가 사용되는 모"
+"든 부분에서 인라인 됩니다:"
 
-#: src/basic-syntax/static-and-const.md:9
+#: src/basic-syntax/static-and-const.md:11
 msgid ""
 "```rust,editable\n"
 "const DIGEST_SIZE: usize = 3;\n"
@@ -3942,23 +4352,36 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/basic-syntax/static-and-const.md:27
+#: src/basic-syntax/static-and-const.md:29
 msgid ""
-"According the the [Rust RFC Book](https://rust-lang.github.io/rfcs/0246-"
-"const-vs-static.html) these are inlined upon use."
+"According to the [Rust RFC Book](https://rust-lang.github.io/rfcs/0246-const-"
+"vs-static.html) these are inlined upon use."
 msgstr ""
 "[Rust RFC Book](https://rust-lang.github.io/rfcs/0246-const-vs-static.html)"
 "에 따르면 상수는, 그 상수가 사용되는 곳에 인라인 됩니다."
 
-#: src/basic-syntax/static-and-const.md:29
+#: src/basic-syntax/static-and-const.md:31
+msgid ""
+"Only functions marked `const` can be called at compile time to generate "
+"`const` values. `const` functions can however be called at runtime."
+msgstr ""
+"`const` 값을 생성할 때에는 `const`로 마킹된 함수만이 호출 가능하며, 이 함수들"
+"은 컴파일 시에 호출이 됩니다. 물론 `const`함수들을 런타임에 호출하는 것도 가"
+"능합니다."
+
+#: src/basic-syntax/static-and-const.md:33
 msgid "`static`"
 msgstr "정적변수(`static`)"
 
-#: src/basic-syntax/static-and-const.md:31
-msgid "You can also declare static variables:"
-msgstr "마찬가지로 정적 변수도 선언할 수 있습니다:"
+#: src/basic-syntax/static-and-const.md:35
+msgid ""
+"Static variables will live during the whole execution of the program, and "
+"therefore will not move:"
+msgstr ""
+"정적 변수는 프로그램이 수행되는 동안 유지가 됩니다. 그러므로 다른 변수로 이동"
+"(move)되지 않습니다:"
 
-#: src/basic-syntax/static-and-const.md:33
+#: src/basic-syntax/static-and-const.md:37
 msgid ""
 "```rust,editable\n"
 "static BANNER: &str = \"Welcome to RustOS 3.14\";\n"
@@ -3976,37 +4399,60 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/basic-syntax/static-and-const.md:41
+#: src/basic-syntax/static-and-const.md:45
 msgid ""
 "As noted in the [Rust RFC Book](https://rust-lang.github.io/rfcs/0246-const-"
 "vs-static.html), these are not inlined upon use and have an actual "
-"associated memory location.  This is useful for unsafe and embedded code, "
-"and the variable lives through the entirety of the program execution."
+"associated memory location.  This is useful for unsafe and  embedded code, "
+"and the variable lives through the entirety of the program execution. When a "
+"globally-scoped value does not have a reason to need object identity, "
+"`const` is generally preferred."
 msgstr ""
 "[Rust RFC Book](https://rust-lang.github.io/rfcs/0246-const-vs-static.html)에"
 "서 언급한 바와 같이, 정적 변수는 별도의 메모리 공간을 가지며, 인라인 되지 않"
 "습니다. 정적 변수는 안전하지 않은(unsafe) 러스트와 임베디드 시스템용 코드에"
-"서 유용합니다. 이들의 수명은 프로그램이 수행되는 전체 시간과 동일합니다."
-
-#: src/basic-syntax/static-and-const.md:44
-msgid ""
-"We will look at mutating static data in the [chapter on Unsafe Rust](../"
-"unsafe.md)."
-msgstr ""
-"가변 정적 데이터에 대해서는 [안전하지 않은 러스트](../unsafe.md)에서 살펴봅니"
-"다."
-
-#: src/basic-syntax/static-and-const.md:48
-msgid "Mention that `const` behaves semantically similar to C++'s `constexpr`."
-msgstr "`const`는 C++의 `constexpr`과 매우 비슷합니다."
+"서 유용합니다. 이들의 수명은 프로그램이 수행되는 전체 시간과 동일합니다. 전"
+"역 스코프를 가진 어떤 값이, 메모리 상에 단 하나만 존재해야 한다는 요구조건이 "
+"없다면, 정적 변수 대신 `const`를 쓰는 것이 옳습니다."
 
 #: src/basic-syntax/static-and-const.md:49
 msgid ""
+"Because `static` variables are accessible from any thread, they must be "
+"`Sync`. Interior mutability is possible through a [`Mutex`](https://doc.rust-"
+"lang.org/std/sync/struct.Mutex.html), atomic or similar. It is also possible "
+"to have mutable statics, but they require manual synchronisation so any "
+"access to them requires `unsafe` code. We will look at [mutable statics](../"
+"unsafe/mutable-static-variables.md) in the chapter on Unsafe Rust."
+msgstr ""
+"`static`변수들은 어떤 스레드에서도 접근 가능하기 때문에, `Sync`트레잇을 구현"
+"해야 합니다. 이 변수를 읽고 쓰려면 [`Mutex`](https://doc.rust-lang.org/std/"
+"sync/struct.Mutex.html)로 감싸거나, atomic 연산을 써야 합니다. `static` 변수"
+"를 mutable하게 선언할 수도 있지만, 이 경우 동기화 작업을 수동으로 해 주어야 "
+"합니다. 그래서 그러한 변수를 접근하는 코드는`unsafe`로 명시적으로 표시가 되어"
+"야 합니다. \"안전하지 않은 러스트\"를 배울 때 [mutable statics](../unsafe/"
+"mutable-static-variables.md) 부분에서 좀 더 자세히 다루겠습니다."
+
+#: src/basic-syntax/static-and-const.md:57
+msgid "Mention that `const` behaves semantically similar to C++'s `constexpr`."
+msgstr "러스트의 `const`는 C++의 `constexpr`과 매우 비슷합니다."
+
+#: src/basic-syntax/static-and-const.md:58
+msgid ""
 "`static`, on the other hand, is much more similar to a `const` or mutable "
 "global variable in C++."
-msgstr "반면에 `static`은 C++의 `const`나 가변 정적 변수와 훨씬 더 유사합니다."
+msgstr ""
+"반면에 러스트의 `static`은 C++의 `const`나 가변 정적 변수(mutable global "
+"variable)와 훨씬 더 유사합니다."
 
-#: src/basic-syntax/static-and-const.md:50
+#: src/basic-syntax/static-and-const.md:59
+msgid ""
+"`static` provides object identity: an address in memory and state as "
+"required by types with interior mutability such as `Mutex<T>`."
+msgstr ""
+"`static`은 객체에 정체성을 부여합니다. 정체정이란 메모리 상에서의 주소, 그리"
+"고 내부 상태를 의미합니다."
+
+#: src/basic-syntax/static-and-const.md:60
 msgid ""
 "It isn't super common that one would need a runtime evaluated constant, but "
 "it is helpful and safer than using a static."
@@ -4014,6 +4460,73 @@ msgstr ""
 "프로그램 수행시 그 값이 정해지는 상수가 필요한 경우는 드뭅니다. 그러나 그렇다"
 "고 해도, 정적 변수를 사용하는 것 보다는 더 유용하고 안전합니다."
 
+#: src/basic-syntax/static-and-const.md:61
+msgid "`thread_local` data can be created with the macro `std::thread_local`."
+msgstr ""
+"`thread_local` 데이터는 `std::thread_local` 매크로를 이용하여 생성할 수 있습"
+"니다."
+
+#: src/basic-syntax/static-and-const.md:63
+msgid "Properties table:"
+msgstr "속성 비교 테이블:"
+
+#: src/basic-syntax/static-and-const.md:65
+msgid "Property"
+msgstr "속성"
+
+#: src/basic-syntax/static-and-const.md:65
+msgid "Static"
+msgstr "정적(static) 변수"
+
+#: src/basic-syntax/static-and-const.md:65
+msgid "Constant"
+msgstr "상수(constant)"
+
+#: src/basic-syntax/static-and-const.md:67
+msgid "Has an address in memory"
+msgstr "메모리 상에 주소가 있는가"
+
+#: src/basic-syntax/static-and-const.md:67
+#: src/basic-syntax/static-and-const.md:68
+#: src/basic-syntax/static-and-const.md:70
+#: src/basic-syntax/static-and-const.md:71
+msgid "Yes"
+msgstr "예"
+
+#: src/basic-syntax/static-and-const.md:67
+msgid "No (inlined)"
+msgstr "아니오(인라인 됨)"
+
+#: src/basic-syntax/static-and-const.md:68
+msgid "Lives for the entire duration of the program"
+msgstr "프로그램이 수행되는 동안 계속 살아 있는가"
+
+#: src/basic-syntax/static-and-const.md:68
+#: src/basic-syntax/static-and-const.md:69
+#: src/basic-syntax/static-and-const.md:71
+msgid "No"
+msgstr "아니오"
+
+#: src/basic-syntax/static-and-const.md:69
+msgid "Can be mutable"
+msgstr "변경 가능한가"
+
+#: src/basic-syntax/static-and-const.md:69
+msgid "Yes (unsafe)"
+msgstr "예 (그러나 안전하지 않음)"
+
+#: src/basic-syntax/static-and-const.md:70
+msgid "Evaluated at compile time"
+msgstr "컴파일시 그 값이 결정되는가"
+
+#: src/basic-syntax/static-and-const.md:70
+msgid "Yes (initialised at compile time)"
+msgstr "예 (컴파일시 초기화 됨)"
+
+#: src/basic-syntax/static-and-const.md:71
+msgid "Inlined wherever it is used"
+msgstr "사용되는 곳에 인라인 되는가"
+
 #: src/basic-syntax/scopes-shadowing.md:3
 msgid ""
 "You can shadow variables, both those from outer scopes and variables from "
@@ -4066,11 +4579,11 @@ msgstr ""
 "쉐도잉은 기존 변수에 새로운 값을 할당하는 것이 아닙니다. 쉐도잉을 하면 새로"
 "운 변수가 생기며, 이전 변수와 새 변수는 메모리의 서로 다른 위치에 존재합니"
 "다. 그 두 변수는 단지 이름이 같은 뿐이며, 코드 중 어디에서 그 이름이 사용되었"
-"느냐에 따라 어떤 변수를 지칭하는 지가 결정됩니다."
+"느냐에 따라 어떤 변수를 지칭하는 지가 결정됩니다. "
 
 #: src/basic-syntax/scopes-shadowing.md:26
 msgid "A shadowing variable can have a different type. "
-msgstr "쉐도잉 시 타입을 바꿀 수 있습니다."
+msgstr "쉐도잉 시 타입을 바꿀 수 있습니다. "
 
 #: src/basic-syntax/scopes-shadowing.md:27
 msgid ""
@@ -4138,7 +4651,7 @@ msgid ""
 "Full control _and_ safety via compile time enforcement of correct memory "
 "management."
 msgstr ""
-"컴파일 시 올바른 메모리 관리를 강제함으로써 완전한 통제와 안전성 모두 제공"
+"컴파일 시 올바른 메모리 관리를 강제함으로써 완전한 통제와 안전성 _모두_ 제공."
 
 #: src/memory-management.md:13
 msgid "It does this with an explicit ownership concept."
@@ -4154,11 +4667,11 @@ msgstr "스택(Stack)과 힙(Heap)"
 
 #: src/memory-management/stack-vs-heap.md:3
 msgid "Stack: Continuous area of memory for local variables."
-msgstr "스택: 지역 변수를 위한 연속적인 메모리 영역"
+msgstr "스택: 로컬 변수를 위한 연속적인 메모리 영역."
 
 #: src/memory-management/stack-vs-heap.md:4
 msgid "Values have fixed sizes known at compile time."
-msgstr "여기 저장되는 값은 컴파일 시 결정되는 고정 크기를 갖습니다. "
+msgstr "여기 저장되는 값은 컴파일 시 결정되는 고정 크기를 갖습니다."
 
 #: src/memory-management/stack-vs-heap.md:5
 msgid "Extremely fast: just move a stack pointer."
@@ -4171,13 +4684,11 @@ msgstr "관리가 쉬움: 함수가 호출되면 할당되고, 리턴하면 반
 
 #: src/memory-management/stack-vs-heap.md:7
 msgid "Great memory locality."
-msgstr ""
-"스택에 있는 값들은 매우 높은 메모리 인접성을 가집니다(_역주_: 그래서 캐시를 "
-"효과적으로 활용할 수 있습니다)"
+msgstr "스택에 있는 값들은 매우 높은 메모리 인접성을 가집니다."
 
 #: src/memory-management/stack-vs-heap.md:9
 msgid "Heap: Storage of values outside of function calls."
-msgstr "힙: 함수 호출/리턴과 상관 없이 유지되는 값이 저장되는 곳"
+msgstr "힙: 함수 호출/리턴과 상관 없이 유지되는 값이 저장되는 곳."
 
 #: src/memory-management/stack-vs-heap.md:10
 msgid "Values have dynamic sizes determined at runtime."
@@ -4191,14 +4702,17 @@ msgstr "스택 보다는 느림: 메모리 할당/반환시 해야 할 일이 
 msgid "No guarantee of memory locality."
 msgstr "메모리 인접성을 보장하지 않습니다."
 
+#: src/memory-management/stack.md:1
+msgid "Stack and Heap Example"
+msgstr "스택과 힙에 관한 예제"
+
 #: src/memory-management/stack.md:3
 msgid ""
-"Creating a `String` puts fixed-sized data on the stack and dynamically sized "
-"data on the heap:"
+"Creating a `String` puts fixed-sized metadata on the stack and dynamically "
+"sized data, the actual string, on the heap:"
 msgstr ""
-"`String` 타입은 고정 크기 데이터(_역주_: 문자열의 길이, 문자열이 저장된 버퍼"
-"의 주소 등)는 스택에 저장하고, 가변 크기 데이터(_역주_: 문자열 버퍼)는 힙에 "
-"저장합니다:"
+"`String`을 하나 만들게 되면, 스택에는 고정된 크기의 메타 데이터가 생성되고, "
+"힙에는 가변 크기의 데이터, 즉, 실제 문자열, 이 생성됩니다:"
 
 #: src/memory-management/stack.md:6
 msgid ""
@@ -4269,8 +4783,8 @@ msgid ""
 "We can inspect the memory layout with `unsafe` code. However, you should "
 "point out that this is rightfully unsafe!"
 msgstr ""
-"`unsafe` 코드로 메모리 레이아웃을 살펴볼 수 있습니다. 물론 이 코드가 안전하"
-"지 않다는 점을 알려주세요!"
+"아래와 같은 `unsafe` 코드로 메모리 레이아웃을 살펴볼 수 있습니다. 물론 이 코"
+"드가 안전하지 않다는 점을 알려주세요!"
 
 #: src/memory-management/stack.md:34
 msgid ""
@@ -4284,7 +4798,7 @@ msgid ""
 "to\n"
 "    // undefined behavior.\n"
 "    unsafe {\n"
-"        let (capacity, ptr, len): (usize, usize, usize) = std::mem::"
+"        let (ptr, capacity, len): (usize, usize, usize) = std::mem::"
 "transmute(s1);\n"
 "        println!(\"ptr = {ptr:#x}, len = {len}, capacity = {capacity}\");\n"
 "    }\n"
@@ -4301,11 +4815,12 @@ msgstr ""
 "to\n"
 "    // undefined behavior.\n"
 "    unsafe {\n"
-"        let (capacity, ptr, len): (usize, usize, usize) = std::mem::"
+"        let (ptr, capacity, len): (usize, usize, usize) = std::mem::"
 "transmute(s1);\n"
 "        println!(\"ptr = {ptr:#x}, len = {len}, capacity = {capacity}\");\n"
 "    }\n"
 "}\n"
+"\n"
 "```"
 
 #: src/memory-management/manual.md:3
@@ -4332,7 +4847,7 @@ msgstr "`malloc`으로 할당하는 포인터마다 `free`를 호출해야 합
 msgid ""
 "```c\n"
 "void foo(size_t n) {\n"
-"    int* int_array = (int*)malloc(n * sizeof(int));\n"
+"    int* int_array = malloc(n * sizeof(int));\n"
 "    //\n"
 "    // ... lots of code\n"
 "    //\n"
@@ -4342,7 +4857,7 @@ msgid ""
 msgstr ""
 "```c\n"
 "void foo(size_t n) {\n"
-"    int* int_array = (int*)malloc(n * sizeof(int));\n"
+"    int* int_array = malloc(n * sizeof(int));\n"
 "    //\n"
 "    // ... lots of code\n"
 "    //\n"
@@ -4353,10 +4868,14 @@ msgstr ""
 #: src/memory-management/manual.md:21
 msgid ""
 "Memory is leaked if the function returns early between `malloc` and `free`: "
-"the pointer is lost and we cannot deallocate the memory."
+"the pointer is lost and we cannot deallocate the memory. Worse, freeing the "
+"pointer twice, or accessing a freed pointer can lead to exploitable security "
+"vulnerabilities."
 msgstr ""
 "만약 `malloc` 과 `free` 사이에서 함수가 일찍 반환되면 메모리 누출이 일어납니"
-"다: 포인터를 잃어버리게 되어 메모리를 반환할 수 없게 됩니다."
+"다: 포인터를 잃어버리게 되어 메모리를 반환할 수 없게 됩니다. 같은 포인터를 "
+"두 번 반환하거나, 이미 반환된 포인터를 접근하는 것은 심각한 보안 문제를 일으"
+"킬 수 있습니다."
 
 #: src/memory-management/scope-based.md:3
 msgid ""
@@ -4514,9 +5033,9 @@ msgstr ""
 "럼 런타임 오버헤드가 없는 것도 있습니다."
 
 #: src/memory-management/rust.md:10
-msgid "It achieves this by modeling _ownership_ explicitly."
+msgid "Rust achieves this by modeling _ownership_ explicitly."
 msgstr ""
-"러스트는 _소유권_을 언어 차원에서 명시적으로 모델링 함으로써 이를 이룹니다."
+"러스트는 \\_소유권_을 언어 차원에서 명시적으로 모델링 함으로써 이를 이룹니다."
 
 #: src/memory-management/rust.md:14
 msgid ""
@@ -4554,16 +5073,16 @@ msgstr "메모리 관리 방법 별 장점"
 
 #: src/memory-management/comparison.md:7 src/memory-management/comparison.md:22
 msgid "Manual like C:"
-msgstr "C와 같은 수동 관리: "
+msgstr "C와 같은 수동 관리:"
 
 #: src/memory-management/comparison.md:8 src/memory-management/comparison.md:14
 #: src/memory-management/comparison.md:17
 msgid "No runtime overhead."
-msgstr "런타임 오버헤드가 없음. "
+msgstr "런타임 오버헤드가 없음."
 
 #: src/memory-management/comparison.md:9 src/memory-management/comparison.md:26
 msgid "Automatic like Java:"
-msgstr "JAVA와 같은 자동화 관리: "
+msgstr "JAVA와 같은 자동화 관리:"
 
 #: src/memory-management/comparison.md:10
 msgid "Fully automatic."
@@ -4577,15 +5096,15 @@ msgstr "안전하고 정확함."
 #: src/memory-management/comparison.md:12
 #: src/memory-management/comparison.md:29
 msgid "Scope-based like C++:"
-msgstr "C++ 와 같은 범위 기반 관리: "
+msgstr "C++ 와 같은 범위 기반 관리:"
 
 #: src/memory-management/comparison.md:13
 msgid "Partially automatic."
-msgstr "부분 자동화"
+msgstr "부분 자동화."
 
 #: src/memory-management/comparison.md:15
 msgid "Compiler-enforced scope-based like Rust:"
-msgstr "러스트와 같은 컴파일러 수행 범위 기반 관리: "
+msgstr "러스트와 같은 컴파일러 수행 범위 기반 관리:"
 
 #: src/memory-management/comparison.md:16
 msgid "Enforced by compiler."
@@ -4618,24 +5137,28 @@ msgstr ""
 "않고 GC가 동작할 때 까지 기다려야 한다는 점)"
 
 #: src/memory-management/comparison.md:30
-msgid "Complex, opt-in by programmer."
+msgid "Complex, opt-in by programmer (on C++)."
 msgstr "복잡하며, 개발자의 선택사항임."
 
 #: src/memory-management/comparison.md:31
-msgid "Potential for use-after-free."
-msgstr "사용 후 해제 문제 가능성 있음."
+msgid "Circular references can lead to memory leaks"
+msgstr "순환 참조가 발생하면 메모리 누수가 발생함"
 
 #: src/memory-management/comparison.md:32
+msgid "Potential runtime overhead"
+msgstr "런타임 오버헤드 있을 수 있음"
+
+#: src/memory-management/comparison.md:33
 msgid "Compiler-enforced and scope-based like Rust:"
 msgstr "러스트와 같은 컴파일러가 강제하는 수행 범위 기반 관리:"
 
-#: src/memory-management/comparison.md:33
-msgid "Some upfront complexity."
-msgstr "약간의 초기 복잡성."
-
 #: src/memory-management/comparison.md:34
+msgid "Some upfront complexity."
+msgstr "처음에 배울 때 어려움."
+
+#: src/memory-management/comparison.md:35
 msgid "Can reject valid programs."
-msgstr "올바른 프로그램이지만 컴파일러가 거부할 수 있음."
+msgstr "올바른 프로그램이더라도 컴파일러가 거부할 수 있음."
 
 #: src/ownership.md:3
 msgid ""
@@ -4689,8 +5212,8 @@ msgid "We say that the variable _owns_ the value."
 msgstr "이것을 두고 변수가 값을 \"소유\"한다고 표현합니다."
 
 #: src/ownership/move-semantics.md:3
-msgid "An assignment will transfer ownership between variables:"
-msgstr "(변수의) 할당은 소유권을 변수 간에 이동시킵니다:"
+msgid "An assignment will transfer _ownership_ between variables:"
+msgstr "(변수의) 할당은 \\_소유권_을 변수 간에 이동시킵니다:"
 
 #: src/ownership/move-semantics.md:5
 msgid ""
@@ -4717,26 +5240,20 @@ msgid "The assignment of `s1` to `s2` transfers ownership."
 msgstr "`s1`을 `s2`에 할당하여 소유권을 이전시킵니다."
 
 #: src/ownership/move-semantics.md:15
-msgid "The data was _moved_ from `s1` and `s1` is no longer accessible."
-msgstr ""
-"데이터는 `s1`에서 \\_이동_됩니다. 따라서 프로그래머는 `s1`은 더 이상 접근 할 "
-"수 없습니다."
-
-#: src/ownership/move-semantics.md:16
-msgid "When `s1` goes out of scope, nothing happens: it has no ownership."
+msgid "When `s1` goes out of scope, nothing happens: it does not own anything."
 msgstr ""
 "`s1`의 스코프가 종료되면 아무 일도 없습니다: 왜냐하면 `s1`은 아무런 소유권이 "
 "없기 때문입니다."
 
-#: src/ownership/move-semantics.md:17
+#: src/ownership/move-semantics.md:16
 msgid "When `s2` goes out of scope, the string data is freed."
 msgstr "`s2`의 스코프가 종료되면 문자열 데이터는 해제됩니다."
 
-#: src/ownership/move-semantics.md:18
+#: src/ownership/move-semantics.md:17
 msgid "There is always _exactly_ one variable binding which owns a value."
 msgstr "값(데이터)의 소유권을 갖는 변수는 항상 _단_ 하나 입니다."
 
-#: src/ownership/move-semantics.md:22
+#: src/ownership/move-semantics.md:21
 msgid ""
 "Mention that this is the opposite of the defaults in C++, which copies by "
 "value unless you use `std::move` (and the move constructor is defined!)."
@@ -4744,7 +5261,23 @@ msgstr ""
 "이는 C++과 정반대 임을 설명하세요. C++에서는 복사가 기본이고, `std::move` 를 "
 "이용해야만 (그리고 이동 생성자가 정의되어 있어야만!) 소유권 이전이 됩니다."
 
-#: src/ownership/move-semantics.md:24
+#: src/ownership/move-semantics.md:23
+msgid ""
+"It is only the ownership that moves. Whether any machine code is generated "
+"to manipulate the data itself is a matter of optimization, and such copies "
+"are aggressively optimized away."
+msgstr ""
+"실제로 이동되는 것은 소유권일 뿐입니다. 머신 코드 레벨에서 데이터 복사가 일어"
+"날 지 말 지에 대한 것은 컴파일러 내부에서 일어나는 최적화 문제입니다. 이런 복"
+"사는 최적화 과정에서 제거가 됩니다."
+
+#: src/ownership/move-semantics.md:25
+msgid ""
+"Simple values (such as integers) can be marked `Copy` (see later slides)."
+msgstr ""
+"정수와 같은 간단한 값들은 `Copy` (뒤에 설명합니다)로 마킹될 수 있습니다."
+
+#: src/ownership/move-semantics.md:27
 msgid "In Rust, clones are explicit (by using `clone`)."
 msgstr "러스트에서는 복사할때에는 명시적으로 `clone`을 사용합니다."
 
@@ -4857,6 +5390,10 @@ msgstr ""
 "`- - - - - - - - - - - - - -'\n"
 "```"
 
+#: src/ownership/double-free-modern-cpp.md:1
+msgid "Extra Work in Modern C++"
+msgstr "Modern C++에서 이중해제 문제"
+
 #: src/ownership/double-free-modern-cpp.md:3
 msgid "Modern C++ solves this differently:"
 msgstr "Modern C++은 이 문제를 다르게 해결합니다:"
@@ -5228,15 +5765,17 @@ msgstr "스택에 할당된 값을 리턴하는 것에 대한 참고:"
 msgid ""
 "Demonstrate that the return from `add` is cheap because the compiler can "
 "eliminate the copy operation. Change the above code to print stack addresses "
-"and run it on the [Playground](https://play.rust-lang.org/). In the "
-"\"DEBUG\" optimization level, the addresses should change, while they stay "
-"the same when changing to the \"RELEASE\" setting:"
+"and run it on the [Playground](https://play.rust-lang.org/) or look at the "
+"assembly in [Godbolt](https://rust.godbolt.org/). In the \"DEBUG\" "
+"optimization level, the addresses should change, while they stay the same "
+"when changing to the \"RELEASE\" setting:"
 msgstr ""
 "`add`에서 값을 반환하는 것은 매우 값이 싸다는 것을 설명하세요. 왜냐하면, 컴파"
 "일러가 복사 과정을 생략할 수 있기 때문입니다. 위 코드를 스택 주소를 출력하도"
-"록 수정하고 [Playground](https://play.rust-lang.org/)에서 수행해 보세요. \"디"
-"버그\" 최적화 레벨에서는 주소가 바뀌지만, \"릴리즈\" 레벨에서는 바뀌지 않습니"
-"다:"
+"록 수정하고 [Playground](https://play.rust-lang.org/)에서 수행해 보세요. 또"
+"는 [Godbolt](https://rust.godbolt.org/)에서 어셈블리를 확인해 보세요. 최적화 "
+"레벨이 \"DEBUG\" 일 때에는 주소가 바뀌지만, \"RELEASE\" 레벨에서는 바뀌지 않"
+"습니다:"
 
 #: src/ownership/borrowing.md:30
 msgid ""
@@ -5250,7 +5789,7 @@ msgid ""
 "    p\n"
 "}\n"
 "\n"
-"fn main() {\n"
+"pub fn main() {\n"
 "    let p1 = Point(3, 4);\n"
 "    let p2 = Point(10, 20);\n"
 "    let p3 = add(&p1, &p2);\n"
@@ -5269,7 +5808,7 @@ msgstr ""
 "    p\n"
 "}\n"
 "\n"
-"fn main() {\n"
+"pub fn main() {\n"
 "    let p1 = Point(3, 4);\n"
 "    let p2 = Point(10, 20);\n"
 "    let p3 = add(&p1, &p2);\n"
@@ -5286,8 +5825,8 @@ msgstr "러스트 컴파일러는 반환값 최적화(RVO)를 수행할 수 있
 msgid ""
 "In C++, copy elision has to be defined in the language specification because "
 "constructors can have side effects. In Rust, this is not an issue at all. If "
-"RVO did not happen, Rust will always performs a simple and efficient "
-"`memcpy` copy."
+"RVO did not happen, Rust will always perform a simple and efficient `memcpy` "
+"copy."
 msgstr ""
 "C++에서 copy elision은 생성자의 부수효과 가능성이 있어 언어레벨의 정의가 필요"
 "하지만 러스트에서는 문제가 되지 않습니다. 만약 RVO가 발생하지 않으면 러스트"
@@ -5338,7 +5877,6 @@ msgstr ""
 "```"
 
 #: src/ownership/shared-unique-borrows.md:25
-#, fuzzy
 msgid ""
 "The above code does not compile because `a` is borrowed as mutable (through "
 "`c`) and as immutable (through `b`) at the same time."
@@ -5347,7 +5885,6 @@ msgstr ""
 "동시에 `b`는 `a`를 불변 변수로 빌렸기 때문입니다."
 
 #: src/ownership/shared-unique-borrows.md:26
-#, fuzzy
 msgid ""
 "Move the `println!` statement for `b` before the scope that introduces `c` "
 "to make the code compile."
@@ -5356,7 +5893,6 @@ msgstr ""
 "다."
 
 #: src/ownership/shared-unique-borrows.md:27
-#, fuzzy
 msgid ""
 "After that change, the compiler realizes that `b` is only ever used before "
 "the new mutable borrow of `a` through `c`. This is a feature of the borrow "
@@ -5364,21 +5900,14 @@ msgid ""
 msgstr ""
 "이렇게 바꾸면, 컴파일러는 `c`가 `a`를 가변 변수로 빌리기 전에만 `b`가 사용된"
 "다는 것을 확인할 수 있습니다. 빌림 검사기의 이러한 기능을 \"non-lexical "
-"lifetime\" 이라고 합니다.\n"
-"\n"
-"단순히 스코프만 보면 `b`의 수명은 `main`함수의 전체라고 생각할 수 있습니다. "
-"때문에 `c`의 블록 안에서는 `a`에 대한 가변 빌림과 불변 빌림이 동시에 존재하"
-"는 것 처럼 보이며, 이는 위 제약 조건을 위반하는 것으로 생각할 수 있습니다. 그"
-"러나 컴파일러는 `b`가 `c`블록이 시작되기 전에만 사용된다는 점을 적극 활용해"
-"서 `b`의 수명을 `c`블록의 시작 전 까지로 줄입니다. 그러면 `b`와 `c`의 수명은 "
-"겹치지 않고, 따라서 제약 조건을 위반하지 않습니다."
+"lifetime\" 이라고 합니다."
 
 #: src/ownership/lifetimes.md:3
 msgid "A borrowed value has a _lifetime_:"
 msgstr "빌려온 값은 _수명_을 갖습니다:"
 
 #: src/ownership/lifetimes.md:5
-msgid "The lifetime can be elided: `add(p1: &Point, p2: &Point) -> Point`."
+msgid "The lifetime can be implicit: `add(p1: &Point, p2: &Point) -> Point`."
 msgstr "수명은 생략할 수 있습니다: `add(p1: &Point, p2: &Point) -> Point`."
 
 #: src/ownership/lifetimes.md:6
@@ -5408,6 +5937,16 @@ msgstr ""
 "수명 표기(`'`)은 수명 추론시 제약조건이 됩니다. 컴파일러는 이 제약조건을 만족"
 "시키는 유요한 수명을 추론할 수 있는지 검사를 합니다."
 
+#: src/ownership/lifetimes.md:13
+msgid ""
+"Lifetimes for function arguments and return values must be fully specified, "
+"but Rust allows lifetimes to be elided in most cases with [a few simple "
+"rules](https://doc.rust-lang.org/nomicon/lifetime-elision.html)."
+msgstr ""
+"원래, 함수의 인자와 리턴값에는 수명을 설정해야 합니다. 그러나 [몇 가지 조건]"
+"(https://doc.rust-lang.org/nomicon/lifetime-elision.html)을 만족하는 대부분"
+"의 경우에는 생략할 수 있습니다."
+
 #: src/ownership/lifetimes-function-calls.md:3
 msgid ""
 "In addition to borrowing its arguments, a function can return a borrowed "
@@ -5464,7 +6003,7 @@ msgstr ""
 
 #: src/ownership/lifetimes-function-calls.md:31
 msgid ""
-"Move the declaration of `p2` and `p3` into a a new scope (`{ ... }`), "
+"Move the declaration of `p2` and `p3` into a new scope (`{ ... }`), "
 "resulting in the following code:"
 msgstr "`p2`와 `p3`를 새로운 범위(`{...}`)로 아래 코드와 같이 이동해 봅니다:"
 
@@ -5543,7 +6082,7 @@ msgstr ""
 
 #: src/ownership/lifetimes-function-calls.md:57
 msgid ""
-"Which one is it? The compiler needs to to know, so at the call site the "
+"Which one is it? The compiler needs to know, so at the call site the "
 "returned reference is not used for longer than a variable from where the "
 "reference came from."
 msgstr ""
@@ -5652,7 +6191,7 @@ msgstr "이번 연습문제는 아래 두가지입니다:"
 
 #: src/exercises/day-1/afternoon.md:5
 msgid "A small book library,"
-msgstr "작은 도서관"
+msgstr "작은 도서관,"
 
 #: src/exercises/day-1/afternoon.md:7
 msgid "Iterators and ownership (hard)."
@@ -5672,26 +6211,37 @@ msgid ""
 "fn main() {\n"
 "    let mut vec = vec![10, 20];\n"
 "    vec.push(30);\n"
-"    println!(\"middle value: {}\", vec[vec.len() / 2]);\n"
-"    for item in vec.iter() {\n"
+"    let midpoint = vec.len() / 2;\n"
+"    println!(\"middle value: {}\", vec[midpoint]);\n"
+"    for item in &vec {\n"
 "        println!(\"item: {item}\");\n"
 "    }\n"
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut vec = vec![10, 20];\n"
+"    vec.push(30);\n"
+"    let midpoint = vec.len() / 2;\n"
+"    println!(\"middle value: {}\", vec[midpoint]);\n"
+"    for item in &vec {\n"
+"        println!(\"item: {item}\");\n"
+"    }\n"
+"}\n"
+"```"
 
-#: src/exercises/day-1/book-library.md:17
+#: src/exercises/day-1/book-library.md:18
 msgid ""
-"Use this to create a library application. Copy the code below to <https://"
-"play.rust-lang.org/> and update the types to make it compile:"
+"Use this to model a library's book collection. Copy the code below to "
+"<https://play.rust-lang.org/> and update the types to make it compile:"
 msgstr ""
-"도서관 프로그램을 만들기 위해 아래 코드를 <https://play.rust-lang.org/>에 복"
-"사해서 구현하시면 됩니다:"
+"아래 코드는 도서관에 있는 도서 컬랙션을 모델링 합니다. 아래 코드를 <https://"
+"play.rust-lang.org/>에 복사한 후, 컴파일 되도록 수정해 봅시다:"
 
-#: src/exercises/day-1/book-library.md:20
+#: src/exercises/day-1/book-library.md:21
 msgid ""
 "```rust,should_panic\n"
-"\n"
 "struct Library {\n"
 "    books: Vec<Book>,\n"
 "}\n"
@@ -5711,36 +6261,36 @@ msgid ""
 "    }\n"
 "}\n"
 "\n"
-"// This makes it possible to print Book values with {}.\n"
-"impl std::fmt::Display for Book {\n"
-"    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n"
-"        write!(f, \"{} ({})\", self.title, self.year)\n"
-"    }\n"
-"}\n"
-"\n"
+"// Implement the methods below. Update the `self` parameter to\n"
+"// indicate the method's required level of ownership over the object:\n"
+"//\n"
+"// - `&self` for shared read-only access,\n"
+"// - `&mut self` for unique and mutable access,\n"
+"// - `self` for unique access by value.\n"
 "impl Library {\n"
 "    fn new() -> Library {\n"
-"        unimplemented!()\n"
+"        todo!(\"Initialize and return a `Library` value\")\n"
 "    }\n"
 "\n"
 "    //fn len(self) -> usize {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Return the length of `self.books`\")\n"
 "    //}\n"
 "\n"
 "    //fn is_empty(self) -> bool {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Return `true` if `self.books` is empty\")\n"
 "    //}\n"
 "\n"
 "    //fn add_book(self, book: Book) {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Add a new book to `self.books`\")\n"
 "    //}\n"
 "\n"
 "    //fn print_books(self) {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Iterate over `self.books` and each book's title and "
+"year\")\n"
 "    //}\n"
 "\n"
 "    //fn oldest_book(self) -> Option<&Book> {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Return a reference to the oldest book (if any)\")\n"
 "    //}\n"
 "}\n"
 "\n"
@@ -5751,31 +6301,113 @@ msgid ""
 "fn main() {\n"
 "    let library = Library::new();\n"
 "\n"
-"    //println!(\"Our library is empty: {}\", library.is_empty());\n"
-"\n"
-"    let favorite_book = Book::new(\"Lord of the Rings\", 1954);\n"
-"    println!(\"Our favorite book {favorite_book} should go in the "
-"library\");\n"
-"    //library.add_book(favorite_book);\n"
+"    //println!(\"The library is empty: library.is_empty() -> {}\", library."
+"is_empty());\n"
+"    //\n"
+"    //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
 "    //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
 "1865));\n"
 "    //\n"
+"    //println!(\"The library is no longer empty: library.is_empty() -> {}\", "
+"library.is_empty());\n"
+"    //\n"
+"    //\n"
 "    //library.print_books();\n"
 "    //\n"
 "    //match library.oldest_book() {\n"
-"    //    Some(book) => println!(\"My oldest book is {book}\"),\n"
-"    //    None => println!(\"My library is empty!\"),\n"
+"    //    Some(book) => println!(\"The oldest book is {}\", book.title),\n"
+"    //    None => println!(\"The library is empty!\"),\n"
 "    //}\n"
 "    //\n"
-"    //println!(\"Our library has {} books\", library.len());\n"
-"    for book in library.books {\n"
-"        println!(\"{book}\");\n"
-"    }\n"
+"    //println!(\"The library has {} books\", library.len());\n"
+"    //library.print_books();\n"
 "}\n"
 "```"
 msgstr ""
+"```rust,should_panic\n"
+"struct Library {\n"
+"    books: Vec<Book>,\n"
+"}\n"
+"\n"
+"struct Book {\n"
+"    title: String,\n"
+"    year: u16,\n"
+"}\n"
+"\n"
+"impl Book {\n"
+"    // This is a constructor, used below.\n"
+"    fn new(title: &str, year: u16) -> Book {\n"
+"        Book {\n"
+"            title: String::from(title),\n"
+"            year,\n"
+"        }\n"
+"    }\n"
+"}\n"
+"\n"
+"// Implement the methods below. Update the `self` parameter to\n"
+"// indicate the method's required level of ownership over the object:\n"
+"//\n"
+"// - `&self` for shared read-only access,\n"
+"// - `&mut self` for unique and mutable access,\n"
+"// - `self` for unique access by value.\n"
+"impl Library {\n"
+"    fn new() -> Library {\n"
+"        todo!(\"Initialize and return a `Library` value\")\n"
+"    }\n"
+"\n"
+"    //fn len(self) -> usize {\n"
+"    //    todo!(\"Return the length of `self.books`\")\n"
+"    //}\n"
+"\n"
+"    //fn is_empty(self) -> bool {\n"
+"    //    todo!(\"Return `true` if `self.books` is empty\")\n"
+"    //}\n"
+"\n"
+"    //fn add_book(self, book: Book) {\n"
+"    //    todo!(\"Add a new book to `self.books`\")\n"
+"    //}\n"
+"\n"
+"    //fn print_books(self) {\n"
+"    //    todo!(\"Iterate over `self.books` and each book's title and "
+"year\")\n"
+"    //}\n"
+"\n"
+"    //fn oldest_book(self) -> Option<&Book> {\n"
+"    //    todo!(\"Return a reference to the oldest book (if any)\")\n"
+"    //}\n"
+"}\n"
+"\n"
+"// This shows the desired behavior. Uncomment the code below and\n"
+"// implement the missing methods. You will need to update the\n"
+"// method signatures, including the \"self\" parameter! You may\n"
+"// also need to update the variable bindings within main.\n"
+"fn main() {\n"
+"    let library = Library::new();\n"
+"\n"
+"    //println!(\"The library is empty: library.is_empty() -> {}\", library."
+"is_empty());\n"
+"    //\n"
+"    //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    //\n"
+"    //println!(\"The library is no longer empty: library.is_empty() -> {}\", "
+"library.is_empty());\n"
+"    //\n"
+"    //\n"
+"    //library.print_books();\n"
+"    //\n"
+"    //match library.oldest_book() {\n"
+"    //    Some(book) => println!(\"The oldest book is {}\", book.title),\n"
+"    //    None => println!(\"The library is empty!\"),\n"
+"    //}\n"
+"    //\n"
+"    //println!(\"The library has {} books\", library.len());\n"
+"    //library.print_books();\n"
+"}\n"
+"```"
 
-#: src/exercises/day-1/book-library.md:104
+#: src/exercises/day-1/book-library.md:102
 msgid "[Solution](solutions-afternoon.md#designing-a-library)"
 msgstr "[해답](solutions-afternoon.md#designing-a-library)"
 
@@ -5814,6 +6446,12 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust\n"
+"pub trait Iterator {\n"
+"    type Item;\n"
+"    fn next(&mut self) -> Option<Self::Item>;\n"
+"}\n"
+"```"
 
 #: src/exercises/day-1/iterators-and-ownership.md:20
 msgid "You use this trait like this:"
@@ -5833,6 +6471,17 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v: Vec<i8> = vec![10, 20, 30];\n"
+"    let mut iter = v.iter();\n"
+"\n"
+"    println!(\"v[0]: {:?}\", iter.next());\n"
+"    println!(\"v[1]: {:?}\", iter.next());\n"
+"    println!(\"v[2]: {:?}\", iter.next());\n"
+"    println!(\"No more items: {:?}\", iter.next());\n"
+"}\n"
+"```"
 
 #: src/exercises/day-1/iterators-and-ownership.md:34
 msgid "What is the type returned by the iterator? Test your answer here:"
@@ -5888,6 +6537,14 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust\n"
+"pub trait IntoIterator {\n"
+"    type Item;\n"
+"    type IntoIter: Iterator<Item = Self::Item>;\n"
+"\n"
+"    fn into_iter(self) -> Self::IntoIter;\n"
+"}\n"
+"```"
 
 #: src/exercises/day-1/iterators-and-ownership.md:62
 msgid ""
@@ -5897,7 +6554,7 @@ msgstr "`IntoIterator`의 모든 구현은 반드시 다음의 두 타입을 선
 
 #: src/exercises/day-1/iterators-and-ownership.md:65
 msgid "`Item`: the type we iterate over, such as `i8`,"
-msgstr "`Item`: `i8`과 같이 반복되는 값의 타입"
+msgstr "`Item`: `i8`과 같이 반복되는 값의 타입,"
 
 #: src/exercises/day-1/iterators-and-ownership.md:66
 msgid "`IntoIter`: the `Iterator` type returned by the `into_iter` method."
@@ -5910,7 +6567,7 @@ msgid ""
 msgstr ""
 "`IntoIter`에는 `Item`이 연결되어 있음을 주목하세요. `IntoIter` 반복자는 "
 "`Item` 타입의 데이터를 가리켜야 합니다. 즉, 반복자는 `Option<Item>`을 리턴합"
-"니다."
+"니다"
 
 #: src/exercises/day-1/iterators-and-ownership.md:71
 msgid "Like before, what  is the type returned by the iterator?"
@@ -5929,6 +6586,16 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let v: Vec<String> = vec![String::from(\"foo\"), String::"
+"from(\"bar\")];\n"
+"    let mut iter = v.into_iter();\n"
+"\n"
+"    let v0: Option<..> = iter.next();\n"
+"    println!(\"v0: {v0:?}\");\n"
+"}\n"
+"```"
 
 #: src/exercises/day-1/iterators-and-ownership.md:83
 msgid "`for` Loops"
@@ -5961,6 +6628,20 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v: Vec<String> = vec![String::from(\"foo\"), String::"
+"from(\"bar\")];\n"
+"\n"
+"    for word in &v {\n"
+"        println!(\"word: {word}\");\n"
+"    }\n"
+"\n"
+"    for word in v {\n"
+"        println!(\"word: {word}\");\n"
+"    }\n"
+"}\n"
+"```"
 
 #: src/exercises/day-1/iterators-and-ownership.md:103
 msgid "What is the type of `word` in each loop?"
@@ -5970,15 +6651,15 @@ msgstr "매 루프에서 `word`의 타입은 무엇입니까?"
 msgid ""
 "Experiment with the code above and then consult the documentation for [`impl "
 "IntoIterator for &Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec."
-"html#impl-IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E) and [`impl "
-"IntoIterator for Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec."
-"html#impl-IntoIterator-for-Vec%3CT%2C%20A%3E) to check your answers."
+"html#impl-IntoIterator-for-%26'a+Vec%3CT,+A%3E) and [`impl IntoIterator for "
+"Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-"
+"for-Vec%3CT,+A%3E) to check your answers."
 msgstr ""
-"위 코드에서 실험 해 본 후 다음 문서를 참조해서 답변을 확인하시기 바랍니다: "
+"위 코드에서 실험 해 본 후, 다음 문서를 참조해서 답변을 확인하시기 바랍니다:"
 "[`impl IntoIterator for &Vec<T>`](https://doc.rust-lang.org/std/vec/struct."
-"Vec.html#impl-IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E), [`impl "
-"IntoIterator for Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec."
-"html#impl-IntoIterator-for-Vec%3CT%2C%20A%3E)"
+"Vec.html#impl-IntoIterator-for-%26'a+Vec%3CT,+A%3E), [`impl IntoIterator for "
+"Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-"
+"for-Vec%3CT%2C%20A%3E)"
 
 #: src/welcome-day-2.md:1
 msgid "Welcome to Day 2"
@@ -6069,43 +6750,49 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/structs.md:32
+#: src/structs.md:31 src/enums.md:34 src/enums/sizes.md:28 src/methods.md:30
+#: src/methods/example.md:46 src/pattern-matching.md:25
+#: src/pattern-matching/match-guards.md:22 src/control-flow/blocks.md:43
+msgid "Key Points:"
+msgstr "키 포인트:"
+
+#: src/structs.md:33
 msgid "Structs work like in C or C++."
 msgstr "구조체는 C/C++ 와 유사합니다."
 
-#: src/structs.md:33
+#: src/structs.md:34
 msgid "Like in C++, and unlike in C, no typedef is needed to define a type."
 msgstr ""
 "C++ 와 같지만 C와는 달리 타입을 정의하기 위해 'typedef'가 필요하지 않습니다."
 
-#: src/structs.md:34
+#: src/structs.md:35
 msgid "Unlike in C++, there is no inheritance between structs."
 msgstr "C++ 와 달리 구조체 간 상속은 없습니다."
 
-#: src/structs.md:35
+#: src/structs.md:36
 msgid ""
 "Methods are defined in an `impl` block, which we will see in following "
 "slides."
 msgstr ""
 "메서드는 `impl`블록에 정의 합니다. 다음 슬라이드에서 확인 할 수 있습니다."
 
-#: src/structs.md:36
+#: src/structs.md:37
 msgid ""
 "This may be a good time to let people know there are different types of "
 "structs. "
 msgstr ""
-"사람들에게 다른 종류의 구조체가 있음을 알게 하기에 좋은 시간일 것입니다."
+"사람들에게 다른 종류의 구조체가 있음을 알게 하기에 좋은 시간일 것입니다. "
 
-#: src/structs.md:37
+#: src/structs.md:38
 msgid ""
 "Zero-sized structs `e.g., struct Foo;` might be used when implementing a "
 "trait on some type but don’t have any data that you want to store in the "
 "value itself. "
 msgstr ""
 "0 크기 구조체(예: `struct Foo;`)는 데이터를 가지고 있지 않지만 특정 타입의 트"
-"레잇을 구현할 때 유용합니다."
+"레잇을 구현할 때 유용합니다. "
 
-#: src/structs.md:38
+#: src/structs.md:39
 msgid ""
 "The next slide will introduce Tuple structs, used when the field names are "
 "not important."
@@ -6113,7 +6800,7 @@ msgstr ""
 "다음 슬라이드에서는 필드 이름이 덜 중요할 때 사용할 수 있는 튜플 구조체를 소"
 "개합니다."
 
-#: src/structs.md:39
+#: src/structs.md:40
 msgid ""
 "The syntax `..peter` allows us to copy the majority of the fields from the "
 "old struct without having to explicitly type it all out. It must always be "
@@ -6197,19 +6884,19 @@ msgid ""
 "Newtypes are a great way to encode additional information about the value in "
 "a primitive type, for example:"
 msgstr ""
-"뉴타입은 다음과 같은 원시타입 값에 특별한 의미를 부여하는 데 유용합니다."
+"뉴타입은 기본 타입에 부가적인 의미를 더하는 좋은 방법입니다. 예를 들어:"
 
 #: src/structs/tuple-structs.md:38
 msgid "The number is measured in some units: `Newtons` in the example above."
-msgstr "단위 표시를 위한 숫자: 위 예제에서는 뉴턴 단위 표기를 위해 사용합니다."
+msgstr "숫자값에 단위를 표시할 수 있음: 위에서 `Newtons`이 그 예입니다."
 
 #: src/structs/tuple-structs.md:39
 msgid ""
 "The value passed some validation when it was created, so you no longer have "
 "to validate it again at every use: 'PhoneNumber(String)`or`OddNumber(u32)\\`."
 msgstr ""
-"값이 생성될 때 이미 유효성 검사를 통과 했으므로 추가적인 검사가 필요없는 경"
-"우: `PhoneNumber(String)`또는 `OddNumber(u32)`"
+"값이 생성될 때 이미 유효성 검사를 통과 했으므로 추가적인 검사가 필요없습니"
+"다: `PhoneNumber(String)`또는 `OddNumber(u32)`."
 
 #: src/structs/tuple-structs.md:40
 msgid ""
@@ -6222,13 +6909,21 @@ msgid ""
 "Rust generally doesn’t like inexplicit things, like automatic unwrapping or "
 "for instance using booleans as integers."
 msgstr ""
-"러스트는 대체로 분명하지 않은 것을 싫어합니다. 예를 들면 자동으로 unwrap하거"
-"나 불리언 값을 정수 값으로 사용하는 것들이 그렇습니다."
+"러스트는 분명하지 않은 것을 싫어합니다. 예를 들면 자동으로 unwrap하거나 불리"
+"언 값을 정수 값으로 사용하는 것들이 그렇습니다."
 
 #: src/structs/tuple-structs.md:42
-msgid "Operator overloading is discussed on Day 3 (generics). "
+msgid "Operator overloading is discussed on Day 3 (generics)."
 msgstr "연산자 재정의는 3일차 제네릭 부분에서 다룹니다."
 
+#: src/structs/tuple-structs.md:43
+msgid ""
+"The example is a subtle reference to the [Mars Climate Orbiter](https://en."
+"wikipedia.org/wiki/Mars_Climate_Orbiter) failure."
+msgstr ""
+"이는 [화성 기후 궤도선 (Mars Climate Orbiter)](https://en.wikipedia.org/wiki/"
+"Mars_Climate_Orbiter)의 실패 원인으로 지목된 도량형 입력 오류를 보여줍니다."
+
 #: src/structs/field-shorthand.md:3
 msgid ""
 "If you already have variables with the right names, then you can create the "
@@ -6282,7 +6977,7 @@ msgid ""
 "The `new` function could be written using `Self` as a type, as it is "
 "interchangeable with the struct type name"
 msgstr ""
-"`new`함수를 다음처럼 구조체 이름 대신 `Self`를 사용하여 작성해도 됩니다."
+"`new`함수를 다음처럼 구조체 이름 대신 `Self`를 사용하여 작성해도 됩니다"
 
 #: src/structs/field-shorthand.md:29
 msgid ""
@@ -6338,11 +7033,11 @@ msgid ""
 "}\n"
 "fn create_default() {\n"
 "    let tmp = Person {\n"
-"        ..Default::default()\n"
+"        ..Person::default()\n"
 "    };\n"
 "    let tmp = Person {\n"
 "        name: \"Sam\".to_string(),\n"
-"        ..Default::default()\n"
+"        ..Person::default()\n"
 "    };\n"
 "}\n"
 "```"
@@ -6363,11 +7058,11 @@ msgstr ""
 "}\n"
 "fn create_default() {\n"
 "    let tmp = Person {\n"
-"        ..Default::default()\n"
+"        ..Person::default()\n"
 "    };\n"
 "    let tmp = Person {\n"
 "        name: \"Sam\".to_string(),\n"
-"        ..Default::default()\n"
+"        ..Person::default()\n"
 "    };\n"
 "}\n"
 "```"
@@ -6399,6 +7094,7 @@ msgstr "`enum` 키워드는 몇가지 유형(variant)으로 표현되는 타입
 msgid ""
 "```rust,editable\n"
 "fn generate_random_number() -> i32 {\n"
+"    // Implementation based on https://xkcd.com/221/\n"
 "    4  // Chosen by fair dice roll. Guaranteed to be random.\n"
 "}\n"
 "\n"
@@ -6422,49 +7118,68 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
-
-#: src/enums.md:33 src/enums/sizes.md:29 src/methods.md:30
-#: src/methods/example.md:46 src/pattern-matching.md:25
-#: src/pattern-matching/match-guards.md:22 src/control-flow/blocks.md:42
-msgid "Key Points:"
-msgstr "키 포인트:"
-
-#: src/enums.md:35
-msgid "Enumerations allow you to collect a set of values under one type"
-msgstr "열거형은 값들의 집합을 하나의 타입으로 표현할 수 있게 합니다."
+"```rust,editable\n"
+"fn generate_random_number() -> i32 {\n"
+"    // Implementation based on https://xkcd.com/221/\n"
+"    4  // Chosen by fair dice roll. Guaranteed to be random.\n"
+"}\n"
+"\n"
+"#[derive(Debug)]\n"
+"enum CoinFlip {\n"
+"    Heads,\n"
+"    Tails,\n"
+"}\n"
+"\n"
+"fn flip_coin() -> CoinFlip {\n"
+"    let random_number = generate_random_number();\n"
+"    if random_number % 2 == 0 {\n"
+"        return CoinFlip::Heads;\n"
+"    } else {\n"
+"        return CoinFlip::Tails;\n"
+"    }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    println!(\"You got: {:?}\", flip_coin());\n"
+"}\n"
+"```"
 
 #: src/enums.md:36
-msgid ""
-"This page offers an enum type `CoinFlip` with two variants `Heads` and "
-"`Tail`. You might note the namespace when using variants."
-msgstr ""
-"위의 `CoinFlip` 열거형 타입은 `Heads`와 `Tail` 두가지 variant를 가집니다. 열"
-"거형 타입의 variant는 네임스페이스를 붙여서 사용합니다."
+msgid "Enumerations allow you to collect a set of values under one type"
+msgstr "열거형은 값들의 집합을 하나의 타입으로 표현할 수 있게 합니다"
 
 #: src/enums.md:37
-msgid "This might be a good time to compare Structs and Enums:"
-msgstr "구조체와 열거형을 비교해 볼까요?"
+msgid ""
+"This page offers an enum type `CoinFlip` with two variants `Heads` and "
+"`Tails`. You might note the namespace when using variants."
+msgstr ""
+"위의 `CoinFlip` 열거형 타입은 `Heads`와 `Tail` 두 가지 variant를 가집니다. 열"
+"거형 타입의 variant는 네임스페이스를 붙여서 사용합니다."
 
 #: src/enums.md:38
+msgid "This might be a good time to compare Structs and Enums:"
+msgstr "구조체와 열거형을 비교해 보겠습니다:"
+
+#: src/enums.md:39
 msgid ""
 "In both, you can have a simple version without fields (unit struct) or one "
 "with different types of fields (variant payloads). "
 msgstr ""
 "구조체나 열거형 모두, 필드가 하나도 없는 단순한 형태도 가능 하고, 여러 타입"
-"의 필드를 가질 수도 있습니다."
+"의 필드를 가질 수도 있습니다. "
 
-#: src/enums.md:39
+#: src/enums.md:40
 msgid "In both, associated functions are defined within an `impl` block."
 msgstr "둘 다 연관함수를 `impl`블록으로 정의 할 수 있습니다."
 
-#: src/enums.md:40
+#: src/enums.md:41
 msgid ""
 "You could even implement the different variants of an enum with separate "
 "structs but then they wouldn’t be the same type as they would if they were "
 "all defined in an enum. "
 msgstr ""
 "열거형 타입의 각 variant를 별도의 구조체로 정의할 수도 있지만, 그러면 열거형"
-"을 사용했을 때처럼 하나의 타입으로 취급할 수 없습니다."
+"을 사용했을 때처럼 하나의 타입으로 취급할 수 없습니다. "
 
 #: src/enums/variant-payloads.md:3
 msgid ""
@@ -6562,7 +7277,7 @@ msgid ""
 msgstr ""
 "가장 위에서 부터 어떤 패턴이 주어진 값과 매칭하는지 검사한 다음, 매칭된 것이 "
 "발견되면 화살표를 따라 코드를 수행합니다. 한 번 매칭이 되고 코드가 수행이 되"
-"면, 더이상의 매칭은 없습니다."
+"면, 더이상의 매칭은 없습니다. "
 
 #: src/enums/variant-payloads.md:39
 msgid ""
@@ -6570,7 +7285,7 @@ msgid ""
 "the Rust compiler provides by confirming when all cases are handled. "
 msgstr ""
 "매칭 패턴들이 불충분 하다면 어떤 일이 일어나는지 설명하세요. 러스트 컴파일러"
-"는 모든 가능한 케이스들이 핸들링 되는지 체크한다는 점을 상기시키세요."
+"는 모든 가능한 케이스들이 핸들링 되는지 체크한다는 점을 상기시키세요. "
 
 #: src/enums/variant-payloads.md:40
 msgid "`match` inspects a hidden discriminant field in the `enum`."
@@ -6582,7 +7297,7 @@ msgstr ""
 msgid ""
 "It is possible to retrieve the discriminant by calling `std::mem::"
 "discriminant()`"
-msgstr "`std::mem::discriminant()`를 이용하여 식별자를 얻을 수도 있습니다."
+msgstr "`std::mem::discriminant()`를 이용하여 식별자를 얻을 수도 있습니다"
 
 #: src/enums/variant-payloads.md:42
 msgid ""
@@ -6614,13 +7329,12 @@ msgstr ""
 #: src/enums/sizes.md:5
 msgid ""
 "```rust,editable\n"
+"use std::any::type_name;\n"
 "use std::mem::{align_of, size_of};\n"
 "\n"
-"macro_rules! dbg_size {\n"
-"    ($t:ty) => {\n"
-"        println!(\"{}: size {} bytes, align: {} bytes\",\n"
-"                 stringify!($t), size_of::<$t>(), align_of::<$t>());\n"
-"    };\n"
+"fn dbg_size<T>() {\n"
+"    println!(\"{}: size {} bytes, align: {} bytes\",\n"
+"        type_name::<T>(), size_of::<T>(), align_of::<T>());\n"
 "}\n"
 "\n"
 "enum Foo {\n"
@@ -6629,18 +7343,17 @@ msgid ""
 "}\n"
 "\n"
 "fn main() {\n"
-"    dbg_size!(Foo);\n"
+"    dbg_size::<Foo>();\n"
 "}\n"
 "```"
 msgstr ""
 "```rust,editable\n"
+"use std::any::type_name;\n"
 "use std::mem::{align_of, size_of};\n"
 "\n"
-"macro_rules! dbg_size {\n"
-"    ($t:ty) => {\n"
-"        println!(\"{}: size {} bytes, align: {} bytes\",\n"
-"                 stringify!($t), size_of::<$t>(), align_of::<$t>());\n"
-"    };\n"
+"fn dbg_size<T>() {\n"
+"    println!(\"{}: size {} bytes, align: {} bytes\",\n"
+"        type_name::<T>(), size_of::<T>(), align_of::<T>());\n"
 "}\n"
 "\n"
 "enum Foo {\n"
@@ -6649,11 +7362,11 @@ msgstr ""
 "}\n"
 "\n"
 "fn main() {\n"
-"    dbg_size!(Foo);\n"
+"    dbg_size::<Foo>();\n"
 "}\n"
 "```"
 
-#: src/enums/sizes.md:25
+#: src/enums/sizes.md:24
 msgid ""
 "See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout."
 "html)."
@@ -6661,8 +7374,7 @@ msgstr ""
 "자세한 사항은 [공식문서](https://doc.rust-lang.org/reference/type-layout."
 "html)를 확인하세요."
 
-#: src/enums/sizes.md:31
-#, fuzzy
+#: src/enums/sizes.md:30
 msgid ""
 "Internally Rust is using a field (discriminant) to keep track of the enum "
 "variant."
@@ -6670,14 +7382,12 @@ msgstr ""
 "러스트는 열거형 variant를 구분하기 위해 내부적으로 식별자(discriminant) 필드"
 "를 사용합니다."
 
-#: src/enums/sizes.md:33
-#, fuzzy
+#: src/enums/sizes.md:32
 msgid ""
 "You can control the discriminant if needed (e.g., for compatibility with C):"
-msgstr "C와의 연동과 같은 이유로 식별자를 직접 지정할 수도 있습니다:"
+msgstr "C와의 연동을 위해 식별자 값을 직접 지정할 수도 있습니다:"
 
-#: src/enums/sizes.md:35
-#, fuzzy
+#: src/enums/sizes.md:34
 msgid ""
 "```rust,editable\n"
 "#[repr(u32)]\n"
@@ -6709,8 +7419,7 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/enums/sizes.md:50
-#, fuzzy
+#: src/enums/sizes.md:49
 msgid ""
 "Without `repr`, the discriminant type takes 2 bytes, because 10001 fits 2 "
 "bytes."
@@ -6718,62 +7427,62 @@ msgstr ""
 "`repr` 속성이 없다면 10001이 2 바이트로 표현가능하기 때문에 식별자의 타입 크"
 "기는 2 바이트가 됩니다."
 
-#: src/enums/sizes.md:54
-#, fuzzy
+#: src/enums/sizes.md:53
 msgid "Try out other types such as"
-msgstr "다른 타입들도 확인해보세요."
+msgstr "다른 타입들도 확인해보세요"
+
+#: src/enums/sizes.md:55
+msgid "`dbg_size!(bool)`: size 1 bytes, align: 1 bytes,"
+msgstr "`dbg_size!(bool)`: 크기 1 바이트, 정렬: 1 바이트,"
 
 #: src/enums/sizes.md:56
-#, fuzzy
-msgid "`dbg_size!(bool)`: size 1 bytes, align: 1 bytes,"
-msgstr "`dbg_size!(bool)`: size 1 bytes, align: 1 bytes"
-
-#: src/enums/sizes.md:57
-#, fuzzy
 msgid ""
 "`dbg_size!(Option<bool>)`: size 1 bytes, align: 1 bytes (niche optimization, "
 "see below),"
 msgstr ""
-"`dbg_size!(Option<bool>)`: size 1 bytes, align: 1 bytes (니치 최적화, 아래 설"
-"명 참조)"
+"`dbg_size!(Option<bool>)`: 크기 1 바이트, 정렬: 1 바이트 (니치 최적화, 아래 "
+"설명 참조)"
+
+#: src/enums/sizes.md:57
+msgid "`dbg_size!(&i32)`: size 8 bytes, align: 8 bytes (on a 64-bit machine),"
+msgstr "`dbg_size!(&i32)`: 크기 8 바이트, 정렬: 8 바이트 (64비트 머신인 경우)"
 
 #: src/enums/sizes.md:58
-#, fuzzy
-msgid "`dbg_size!(&i32)`: size 8 bytes, align: 8 bytes (on a 64-bit machine),"
-msgstr "`dbg_size!(&i32)`: size 8 bytes, align: 8 bytes (64비트 머신인 경우)"
-
-#: src/enums/sizes.md:59
-#, fuzzy
 msgid ""
 "`dbg_size!(Option<&i32>)`: size 8 bytes, align: 8 bytes (null pointer "
 "optimization, see below)."
 msgstr ""
-"`dbg_size!(Option<&i32>)`: size 8 bytes, align: 8 bytes (널포인터 최적화, 아"
+"`dbg_size!(Option<&i32>)`: 크기 8 바이트, 정렬: 8 바이트 (널포인터 최적화, 아"
 "래 설명 참조)"
 
-#: src/enums/sizes.md:61
-#, fuzzy
+#: src/enums/sizes.md:60
 msgid ""
-"Niche optimization: Rust will merge use unused bit patterns for the enum "
+"Niche optimization: Rust will merge unused bit patterns for the enum "
 "discriminant."
 msgstr ""
 "니치 최적화: 러스트는 열거형 식별자를 사용되지 않은 비트 패턴과 병합합니다."
 
-#: src/enums/sizes.md:64
+#: src/enums/sizes.md:63
 msgid ""
 "Null pointer optimization: For [some types](https://doc.rust-lang.org/std/"
 "option/#representation), Rust guarantees that `size_of::<T>()` equals "
 "`size_of::<Option<T>>()`."
 msgstr ""
+"널포인터 최적화: [어떤 타입들](https://doc.rust-lang.org/std/option/"
+"#representation)에 대해서 러스트는 `size_of::<T>()`가 `size_of::"
+"<Option<T>>()`와 같은 것을 보장합니다."
 
-#: src/enums/sizes.md:68
+#: src/enums/sizes.md:67
 msgid ""
 "Example code if you want to show how the bitwise representation _may_ look "
 "like in practice. It's important to note that the compiler provides no "
 "guarantees regarding this representation, therefore this is totally unsafe."
 msgstr ""
+"실제로 널포인터 최적화가 적용된 것을 확인하고 싶다면 아래의 예제코드를 사용하"
+"세요. 주의할 점은, 여기에서 보여주는 비트 패턴이 컴파일러가 보장해 주는 것은 "
+"아니라는 점입니다. 여기에 의존하는 것은 완전히 unsafe합니다."
 
-#: src/enums/sizes.md:71
+#: src/enums/sizes.md:70
 msgid ""
 "```rust,editable\n"
 "use std::mem::transmute;\n"
@@ -6811,14 +7520,51 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"use std::mem::transmute;\n"
+"\n"
+"macro_rules! dbg_bits {\n"
+"    ($e:expr, $bit_type:ty) => {\n"
+"        println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, "
+"$bit_type>($e));\n"
+"    };\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    // TOTALLY UNSAFE. Rust provides no guarantees about the bitwise\n"
+"    // representation of types.\n"
+"    unsafe {\n"
+"        println!(\"Bitwise representation of bool\");\n"
+"        dbg_bits!(false, u8);\n"
+"        dbg_bits!(true, u8);\n"
+"\n"
+"        println!(\"Bitwise representation of Option<bool>\");\n"
+"        dbg_bits!(None::<bool>, u8);\n"
+"        dbg_bits!(Some(false), u8);\n"
+"        dbg_bits!(Some(true), u8);\n"
+"\n"
+"        println!(\"Bitwise representation of Option<Option<bool>>\");\n"
+"        dbg_bits!(Some(Some(false)), u8);\n"
+"        dbg_bits!(Some(Some(true)), u8);\n"
+"        dbg_bits!(Some(None::<bool>), u8);\n"
+"        dbg_bits!(None::<Option<bool>>, u8);\n"
+"\n"
+"        println!(\"Bitwise representation of Option<&i32>\");\n"
+"        dbg_bits!(None::<&i32>, usize);\n"
+"        dbg_bits!(Some(&0i32), usize);\n"
+"    }\n"
+"}\n"
+"```"
 
-#: src/enums/sizes.md:106
+#: src/enums/sizes.md:105
 msgid ""
 "More complex example if you want to discuss what happens when we chain more "
 "than 256 `Option`s together."
 msgstr ""
+"아래는 좀 더 복잡한 예제입니다.  256개 이상의 `Option`이 중첩되어 연결되어 있"
+"을 경우 어떻게 되는지 보여줍니다."
 
-#: src/enums/sizes.md:108
+#: src/enums/sizes.md:107
 msgid ""
 "```rust,editable\n"
 "#![recursion_limit = \"1000\"]\n"
@@ -6870,6 +7616,55 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"#![recursion_limit = \"1000\"]\n"
+"\n"
+"use std::mem::transmute;\n"
+"\n"
+"macro_rules! dbg_bits {\n"
+"    ($e:expr, $bit_type:ty) => {\n"
+"        println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, "
+"$bit_type>($e));\n"
+"    };\n"
+"}\n"
+"\n"
+"// Macro to wrap a value in 2^n Some() where n is the number of \"@\" "
+"signs.\n"
+"// Increasing the recursion limit is required to evaluate this macro.\n"
+"macro_rules! many_options {\n"
+"    ($value:expr) => { Some($value) };\n"
+"    ($value:expr, @) => {\n"
+"        Some(Some($value))\n"
+"    };\n"
+"    ($value:expr, @ $($more:tt)+) => {\n"
+"        many_options!(many_options!($value, $($more)+), $($more)+)\n"
+"    };\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    // TOTALLY UNSAFE. Rust provides no guarantees about the bitwise\n"
+"    // representation of types.\n"
+"    unsafe {\n"
+"        assert_eq!(many_options!(false), Some(false));\n"
+"        assert_eq!(many_options!(false, @), Some(Some(false)));\n"
+"        assert_eq!(many_options!(false, @@), "
+"Some(Some(Some(Some(false)))));\n"
+"\n"
+"        println!(\"Bitwise representation of a chain of 128 Option's.\");\n"
+"        dbg_bits!(many_options!(false, @@@@@@@), u8);\n"
+"        dbg_bits!(many_options!(true, @@@@@@@), u8);\n"
+"\n"
+"        println!(\"Bitwise representation of a chain of 256 Option's.\");\n"
+"        dbg_bits!(many_options!(false, @@@@@@@@), u16);\n"
+"        dbg_bits!(many_options!(true, @@@@@@@@), u16);\n"
+"\n"
+"        println!(\"Bitwise representation of a chain of 257 Option's.\");\n"
+"        dbg_bits!(many_options!(Some(false), @@@@@@@@), u16);\n"
+"        dbg_bits!(many_options!(Some(true), @@@@@@@@), u16);\n"
+"        dbg_bits!(many_options!(None::<bool>, @@@@@@@@), u16);\n"
+"    }\n"
+"}\n"
+"```"
 
 #: src/methods.md:3
 msgid ""
@@ -6947,13 +7742,13 @@ msgstr ""
 "할 수 있습니다. 메서드들이 예측 가능한 위치에 모여 있으니 찾기 쉽습니다."
 
 #: src/methods.md:34
-msgid "Point out the use of the keyword `self`, a method receiver. "
+msgid "Point out the use of the keyword `self`, a method receiver."
 msgstr "메서드 receiver인 `self` 키워드 사용을 언급해 주시기 바랍니다."
 
 #: src/methods.md:35
 msgid ""
-"Show that it is an abbreviated term for `self:&Self` and perhaps show how "
-"the struct name could also be used. "
+"Show that it is an abbreviated term for `self: Self` and perhaps show how "
+"the struct name could also be used."
 msgstr ""
 "예제의 경우 `self: &Self`의 줄인 버전임을 알려주고, 구조체의 이름을 직접 사용"
 "하면 어떻게 되는지 보여주는 것도 좋습니다."
@@ -7015,22 +7810,20 @@ msgid ""
 "`self`: takes ownership of the object and moves it away from the caller. The "
 "method becomes the owner of the object. The object will be dropped "
 "(deallocated) when the method returns, unless its ownership is explicitly "
-"transmitted."
+"transmitted. Complete ownership does not automatically mean mutability."
 msgstr ""
 "`self`: 호출자로부터 객체의 소유권을 가져오고 객체는 호출자로부터 메소드로 이"
 "동됩니다. 메소드가 객체를 소유하게 되며 따라서 명시적으로 소유권을 다른 곳으"
 "로 전달하지 않는다면 메서드 종료와 함께 객체는 drop(해제)됩니다."
 
 #: src/methods/receiver.md:14
-msgid ""
-"`mut self`: same as above, but while the method owns the object, it can "
-"mutate it too. Complete ownership does not automatically mean mutability."
+msgid "`mut self`: same as above, but the method can mutate the object. "
 msgstr ""
 "`mut self`: 위와 동일하지만 메서드가 객체의 소유권을 가지면서 동시에 객체를 "
 "수정할 수도 있습니다. 소유권을 가지는 것이 수정할 수 있음을 의미하는 것은 아"
-"닙니다."
+"닙니다. "
 
-#: src/methods/receiver.md:16
+#: src/methods/receiver.md:15
 msgid ""
 "No receiver: this becomes a static method on the struct. Typically used to "
 "create constructors which are called `new` by convention."
@@ -7038,7 +7831,7 @@ msgstr ""
 "리시버 없음: 구조체의 정적 메서드가 됩니다. 주로 생성자를 만들때 사용하게 되"
 "며, 생성자는 흔히 `new`라고 이름붙입니다."
 
-#: src/methods/receiver.md:19
+#: src/methods/receiver.md:18
 msgid ""
 "Beyond variants on `self`, there are also [special wrapper types](https://"
 "doc.rust-lang.org/reference/special-types-and-traits.html) allowed to be "
@@ -7048,7 +7841,7 @@ msgstr ""
 "용되는 [특별한 래퍼 타입](https://doc.rust-lang.org/reference/special-types-"
 "and-traits.html)이 있습니다."
 
-#: src/methods/receiver.md:25
+#: src/methods/receiver.md:24
 msgid ""
 "Consider emphasizing \"shared and immutable\" and \"unique and mutable\". "
 "These constraints always come together in Rust due to borrow checker rules, "
@@ -7150,14 +7943,14 @@ msgstr ""
 
 #: src/methods/example.md:47
 msgid "All four methods here use a different method receiver."
-msgstr "4가지 유형의 메서드 receiver에 대해 설명합니다."
+msgstr "이 네 개의 메서드는 서로 다른 유형의 리시버를 사용합니다."
 
 #: src/methods/example.md:48
 msgid ""
 "You can point out how that changes what the function can do with the "
 "variable values and if/how it can be used again in `main`."
 msgstr ""
-"receiver 유형에 따라 함수가 할 수 있는 일이 달라지고, 또 메소드를 호출한 뒤 "
+"리시버의 유형에 따라 함수가 할 수 있는 일이 달라지고, 또 메소드를 호출한 뒤 "
 "`main`에서 해당 객체를 사용할 수 있는지 여부도 달라진다는 점을 강조하세요."
 
 #: src/methods/example.md:49
@@ -7233,23 +8026,23 @@ msgstr "`_`패턴은 어떤 값과도 매칭되는 와일드카드입니다."
 msgid ""
 "You might point out how some specific characters are being used when in a "
 "pattern"
-msgstr "패턴에서 사용되는 특수 문자들을 알려주세요."
+msgstr "패턴에서 사용되는 특수 문자들을 알려주세요"
 
 #: src/pattern-matching.md:27
 msgid "`|` as an `or`"
-msgstr "`|`: or 기호입니다."
+msgstr "`|`: or 기호입니다"
 
 #: src/pattern-matching.md:28
 msgid "`..` can expand as much as it needs to be"
-msgstr "`..`: 필요한 만큼 확장합니다."
+msgstr "`..`: 필요한 만큼 확장합니다"
 
 #: src/pattern-matching.md:29
 msgid "`1..=5` represents an inclusive range"
-msgstr "`1..=5`: 끝 값(여기서는 5)을 포함하는 범위를 나타냅니다."
+msgstr "`1..=5`: 끝 값(여기서는 5)을 포함하는 범위를 나타냅니다"
 
 #: src/pattern-matching.md:30
 msgid "`_` is a wild card"
-msgstr "`_`: 와일드카드입니다."
+msgstr "`_`: 와일드카드입니다"
 
 #: src/pattern-matching.md:31
 msgid ""
@@ -7400,13 +8193,11 @@ msgstr ""
 
 #: src/pattern-matching/destructuring-structs.md:23
 msgid "Change the literal values in `foo` to match with the other patterns."
-msgstr ""
-"`foo` 인스턴스 생성에 사용된 리터럴 값을 변경해서 다른 패턴에 매치되도록 해보"
-"세요."
+msgstr "`foo`의 리터럴 값을 다른 패턴과 일치하도록 변경합니다."
 
 #: src/pattern-matching/destructuring-structs.md:24
 msgid "Add a new field to `Foo` and make changes to the pattern as needed."
-msgstr "`Foo` 구조체에 새 필드를 추가하고 패턴도 바꿔보세요."
+msgstr "`Foo`에 새 필드를 추가하고 필요에 따라 패턴을 변경합니다."
 
 #: src/pattern-matching/destructuring-structs.md:25
 msgid ""
@@ -7497,7 +8288,7 @@ msgstr ""
 
 #: src/pattern-matching/destructuring-arrays.md:41
 msgid "Create a new pattern using `_` to represent an element. "
-msgstr "`_`를 사용하여 요소를 매칭하는 패턴을 추가해보세요."
+msgstr "`_`를 사용하여 요소를 매칭하는 패턴을 추가해보세요. "
 
 #: src/pattern-matching/destructuring-arrays.md:42
 msgid "Add more values to the array."
@@ -7512,7 +8303,7 @@ msgstr "`..`가 요소 개수에 상관없이 매치될 수 있음을 알려주
 #: src/pattern-matching/destructuring-arrays.md:44
 msgid "Show matching against the tail with patterns `[.., b]` and `[a@..,b]`"
 msgstr ""
-"`[.., b]`나 `[a@.., b]`와 같은 패턴으로 꼬리 부분을 매칭하는 것을 보여주세요."
+"`[.., b]`나 `[a@.., b]`와 같은 패턴으로 꼬리 부분을 매칭하는 것을 보여주세요"
 
 #: src/pattern-matching/match-guards.md:3
 msgid ""
@@ -7628,14 +8419,28 @@ msgid ""
 "// TODO: remove this when you're done with your implementation.\n"
 "#![allow(unused_variables, dead_code)]\n"
 "\n"
-"struct User {\n"
+"pub struct User {\n"
 "    name: String,\n"
 "    age: u32,\n"
-"    weight: f32,\n"
+"    height: f32,\n"
+"    visit_count: usize,\n"
+"    last_blood_pressure: Option<(u32, u32)>,\n"
+"}\n"
+"\n"
+"pub struct Measurements {\n"
+"    height: f32,\n"
+"    blood_pressure: (u32, u32),\n"
+"}\n"
+"\n"
+"pub struct HealthReport<'a> {\n"
+"    patient_name: &'a str,\n"
+"    visit_count: u32,\n"
+"    height_change: f32,\n"
+"    blood_pressure_change: Option<(i32, i32)>,\n"
 "}\n"
 "\n"
 "impl User {\n"
-"    pub fn new(name: String, age: u32, weight: f32) -> Self {\n"
+"    pub fn new(name: String, age: u32, height: f32) -> Self {\n"
 "        unimplemented!()\n"
 "    }\n"
 "\n"
@@ -7647,7 +8452,11 @@ msgid ""
 "        unimplemented!()\n"
 "    }\n"
 "\n"
-"    pub fn weight(&self) -> f32 {\n"
+"    pub fn height(&self) -> f32 {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    pub fn doctor_visits(&self) -> u32 {\n"
 "        unimplemented!()\n"
 "    }\n"
 "\n"
@@ -7655,7 +8464,12 @@ msgid ""
 "        unimplemented!()\n"
 "    }\n"
 "\n"
-"    pub fn set_weight(&mut self, new_weight: f32) {\n"
+"    pub fn set_height(&mut self, new_height: f32) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    pub fn visit_doctor(&mut self, measurements: Measurements) -> "
+"HealthReport {\n"
 "        unimplemented!()\n"
 "    }\n"
 "}\n"
@@ -7666,9 +8480,9 @@ msgid ""
 "}\n"
 "\n"
 "#[test]\n"
-"fn test_weight() {\n"
+"fn test_height() {\n"
 "    let bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
-"    assert_eq!(bob.weight(), 155.2);\n"
+"    assert_eq!(bob.height(), 155.2);\n"
 "}\n"
 "\n"
 "#[test]\n"
@@ -7678,8 +8492,128 @@ msgid ""
 "    bob.set_age(33);\n"
 "    assert_eq!(bob.age(), 33);\n"
 "}\n"
+"\n"
+"#[test]\n"
+"fn test_visit() {\n"
+"    let mut bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    assert_eq!(bob.doctor_visits(), 0);\n"
+"    let report = bob.visit_doctor(Measurements {\n"
+"        height: 156.1,\n"
+"        blood_pressure: (120, 80),\n"
+"    });\n"
+"    assert_eq!(report.patient_name, \"Bob\");\n"
+"    assert_eq!(report.visit_count, 1);\n"
+"    assert_eq!(report.blood_pressure_change, None);\n"
+"\n"
+"    let report = bob.visit_doctor(Measurements {\n"
+"        height: 156.1,\n"
+"        blood_pressure: (115, 76),\n"
+"    });\n"
+"\n"
+"    assert_eq!(report.visit_count, 2);\n"
+"    assert_eq!(report.blood_pressure_change, Some((-5, -4)));\n"
+"}\n"
 "```"
 msgstr ""
+"```rust,should_panic\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_variables, dead_code)]\n"
+"\n"
+"pub struct User {\n"
+"    name: String,\n"
+"    age: u32,\n"
+"    height: f32,\n"
+"    visit_count: usize,\n"
+"    last_blood_pressure: Option<(u32, u32)>,\n"
+"}\n"
+"\n"
+"pub struct Measurements {\n"
+"    height: f32,\n"
+"    blood_pressure: (u32, u32),\n"
+"}\n"
+"\n"
+"pub struct HealthReport<'a> {\n"
+"    patient_name: &'a str,\n"
+"    visit_count: u32,\n"
+"    height_change: f32,\n"
+"    blood_pressure_change: Option<(i32, i32)>,\n"
+"}\n"
+"\n"
+"impl User {\n"
+"    pub fn new(name: String, age: u32, height: f32) -> Self {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    pub fn name(&self) -> &str {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    pub fn age(&self) -> u32 {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    pub fn height(&self) -> f32 {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    pub fn doctor_visits(&self) -> u32 {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    pub fn set_age(&mut self, new_age: u32) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    pub fn set_height(&mut self, new_height: f32) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    pub fn visit_doctor(&mut self, measurements: Measurements) -> "
+"HealthReport {\n"
+"        unimplemented!()\n"
+"    }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    println!(\"I'm {} and my age is {}\", bob.name(), bob.age());\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_height() {\n"
+"    let bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    assert_eq!(bob.height(), 155.2);\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_set_age() {\n"
+"    let mut bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    assert_eq!(bob.age(), 32);\n"
+"    bob.set_age(33);\n"
+"    assert_eq!(bob.age(), 33);\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_visit() {\n"
+"    let mut bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    assert_eq!(bob.doctor_visits(), 0);\n"
+"    let report = bob.visit_doctor(Measurements {\n"
+"        height: 156.1,\n"
+"        blood_pressure: (120, 80),\n"
+"    });\n"
+"    assert_eq!(report.patient_name, \"Bob\");\n"
+"    assert_eq!(report.visit_count, 1);\n"
+"    assert_eq!(report.blood_pressure_change, None);\n"
+"\n"
+"    let report = bob.visit_doctor(Measurements {\n"
+"        height: 156.1,\n"
+"        blood_pressure: (115, 76),\n"
+"    });\n"
+"\n"
+"    assert_eq!(report.visit_count, 2);\n"
+"    assert_eq!(report.blood_pressure_change, Some((-5, -4)));\n"
+"}\n"
+"```"
 
 #: src/exercises/day-2/points-polygons.md:1
 msgid "Polygon Struct"
@@ -7805,6 +8739,113 @@ msgid ""
 "fn main() {}\n"
 "```"
 msgstr ""
+"```rust\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_variables, dead_code)]\n"
+"\n"
+"pub struct Point {\n"
+"    // add fields\n"
+"}\n"
+"\n"
+"impl Point {\n"
+"    // add methods\n"
+"}\n"
+"\n"
+"pub struct Polygon {\n"
+"    // add fields\n"
+"}\n"
+"\n"
+"impl Polygon {\n"
+"    // add methods\n"
+"}\n"
+"\n"
+"pub struct Circle {\n"
+"    // add fields\n"
+"}\n"
+"\n"
+"impl Circle {\n"
+"    // add methods\n"
+"}\n"
+"\n"
+"pub enum Shape {\n"
+"    Polygon(Polygon),\n"
+"    Circle(Circle),\n"
+"}\n"
+"\n"
+"#[cfg(test)]\n"
+"mod tests {\n"
+"    use super::*;\n"
+"\n"
+"    fn round_two_digits(x: f64) -> f64 {\n"
+"        (x * 100.0).round() / 100.0\n"
+"    }\n"
+"\n"
+"    #[test]\n"
+"    fn test_point_magnitude() {\n"
+"        let p1 = Point::new(12, 13);\n"
+"        assert_eq!(round_two_digits(p1.magnitude()), 17.69);\n"
+"    }\n"
+"\n"
+"    #[test]\n"
+"    fn test_point_dist() {\n"
+"        let p1 = Point::new(10, 10);\n"
+"        let p2 = Point::new(14, 13);\n"
+"        assert_eq!(round_two_digits(p1.dist(p2)), 5.00);\n"
+"    }\n"
+"\n"
+"    #[test]\n"
+"    fn test_point_add() {\n"
+"        let p1 = Point::new(16, 16);\n"
+"        let p2 = p1 + Point::new(-4, 3);\n"
+"        assert_eq!(p2, Point::new(12, 19));\n"
+"    }\n"
+"\n"
+"    #[test]\n"
+"    fn test_polygon_left_most_point() {\n"
+"        let p1 = Point::new(12, 13);\n"
+"        let p2 = Point::new(16, 16);\n"
+"\n"
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(p1);\n"
+"        poly.add_point(p2);\n"
+"        assert_eq!(poly.left_most_point(), Some(p1));\n"
+"    }\n"
+"\n"
+"    #[test]\n"
+"    fn test_polygon_iter() {\n"
+"        let p1 = Point::new(12, 13);\n"
+"        let p2 = Point::new(16, 16);\n"
+"\n"
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(p1);\n"
+"        poly.add_point(p2);\n"
+"\n"
+"        let points = poly.iter().cloned().collect::<Vec<_>>();\n"
+"        assert_eq!(points, vec![Point::new(12, 13), Point::new(16, 16)]);\n"
+"    }\n"
+"\n"
+"    #[test]\n"
+"    fn test_shape_perimeters() {\n"
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(Point::new(12, 13));\n"
+"        poly.add_point(Point::new(17, 11));\n"
+"        poly.add_point(Point::new(16, 16));\n"
+"        let shapes = vec![\n"
+"            Shape::from(poly),\n"
+"            Shape::from(Circle::new(Point::new(10, 20), 5)),\n"
+"        ];\n"
+"        let perimeters = shapes\n"
+"            .iter()\n"
+"            .map(Shape::perimeter)\n"
+"            .map(round_two_digits)\n"
+"            .collect::<Vec<_>>();\n"
+"        assert_eq!(perimeters, vec![15.48, 31.42]);\n"
+"    }\n"
+"}\n"
+"\n"
+"#[allow(dead_code)]\n"
+"fn main() {}\n"
+"```"
 
 #: src/exercises/day-2/points-polygons.md:117
 msgid ""
@@ -7848,13 +8889,13 @@ msgstr ""
 
 #: src/control-flow/blocks.md:3
 msgid ""
-"A block in Rust has a value and a type: the value is the last expression of "
-"the block:"
+"A block in Rust contains a sequence of expressions. Each block has a value "
+"and a type, which are those of the last expression of the block:"
 msgstr ""
 "러스트에서 블록은 값과 타입을 갖습니다. 블록의 마지막 표현식이 블록의 값이 됩"
 "니다:"
 
-#: src/control-flow/blocks.md:6
+#: src/control-flow/blocks.md:7
 msgid ""
 "```rust,editable\n"
 "fn main() {\n"
@@ -7894,7 +8935,15 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/control-flow/blocks.md:25
+#: src/control-flow/blocks.md:26
+msgid ""
+"If the last expression ends with `;`, then the resulting value and type is "
+"`()`."
+msgstr ""
+"위의 `main` 함수는 마지막 표현식이 `;`로 끝나기 때문에 반환되는 값과 타입이 "
+"`()`입니다."
+
+#: src/control-flow/blocks.md:28
 msgid ""
 "The same rule is used for functions: the value of the function body is the "
 "return value:"
@@ -7902,7 +8951,7 @@ msgstr ""
 "함수에도 동일한 규칙이 적용됩니다. 함수 바디를 이루는 블록의 값이 반환값이 됩"
 "니다:"
 
-#: src/control-flow/blocks.md:28
+#: src/control-flow/blocks.md:31
 msgid ""
 "```rust,editable\n"
 "fn double(x: i32) -> i32 {\n"
@@ -7924,22 +8973,14 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/control-flow/blocks.md:38
-msgid ""
-"However if the last expression ends with `;`, then the resulting value and "
-"type is `()`."
-msgstr ""
-"위의 `main` 함수는 마지막 표현식이 `;`로 끝나기 때문에 반환되는 값과 타입이 "
-"`()`입니다."
-
-#: src/control-flow/blocks.md:43
+#: src/control-flow/blocks.md:44
 msgid ""
 "The point of this slide is to show that blocks have a type and value in "
 "Rust. "
 msgstr ""
-"러스트에서는 블록이 타입과 값을 가진다는 점이 이 슬라이드의 핵심입니다."
+"러스트에서는 블록이 타입과 값을 가진다는 점이 이 슬라이드의 핵심입니다. "
 
-#: src/control-flow/blocks.md:44
+#: src/control-flow/blocks.md:45
 msgid ""
 "You can show how the value of the block changes by changing the last line in "
 "the block. For instance, adding/removing a semicolon or using a `return`."
@@ -7952,8 +8993,12 @@ msgid "`if` expressions"
 msgstr "`if` 표현식"
 
 #: src/control-flow/if-expressions.md:3
-msgid "You use `if` very similarly to how you would in other languages:"
-msgstr "`if`는 다른 언어와 매우 유사합니다:"
+msgid ""
+"You use [`if` expressions](https://doc.rust-lang.org/reference/expressions/"
+"if-expr.html#if-expressions) exactly like `if` statements in other languages:"
+msgstr ""
+"다른 언어의 `if` 문과 똑같이 [`if` 표현식](https://doc.rust-lang.org/"
+"reference/expressions/if-expr.html#if-expressions)을 사용합니다:"
 
 #: src/control-flow/if-expressions.md:7
 msgid ""
@@ -7979,9 +9024,10 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/control-flow/if-expressions.md:16
+#: src/control-flow/if-expressions.md:18
 msgid ""
-"In addition, you can use it as an expression. This does the same as above:"
+"In addition, you can use `if` as an expression. The last expression of each "
+"block becomes the value of the `if` expression:"
 msgstr ""
 "게다가 `if`는 표현식으로 사용할 수도 있습니다. 아래 코드는 위와 동일합니다:"
 
@@ -8009,7 +9055,7 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/control-flow/if-expressions.md:31
+#: src/control-flow/if-expressions.md:35
 msgid ""
 "Because `if` is an expression and must have a particular type, both of its "
 "branch blocks must have the same type. Consider showing what happens if you "
@@ -8024,9 +9070,14 @@ msgid "`if let` expressions"
 msgstr "`if let` 표현식"
 
 #: src/control-flow/if-let-expressions.md:3
-msgid "If you want to match a value against a pattern, you can use `if let`:"
+msgid ""
+"The [`if let` expression](https://doc.rust-lang.org/reference/expressions/if-"
+"expr.html#if-let-expressions) lets you execute different code depending on "
+"whether a value matches a pattern:"
 msgstr ""
-"어떤 값이 패턴에 매치되는지 검사하려면 `if let` 표현식을 사용하면 됩니다:"
+"[`if let` 표현식](https://doc.rust-lang.org/reference/expressions/if-expr."
+"html#if-let-expressions)을 사용하면 값이 패턴과 일치하는지에 따라 다른 코드"
+"를 실행할 수 있습니다:"
 
 #: src/control-flow/if-let-expressions.md:7
 msgid ""
@@ -8052,50 +9103,85 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/control-flow/if-let-expressions.md:16
+#: src/control-flow/if-let-expressions.md:18
 #: src/control-flow/while-let-expressions.md:21
-#: src/control-flow/match-expressions.md:22
+#: src/control-flow/match-expressions.md:23
 msgid ""
 "See [pattern matching](../pattern-matching.md) for more details on patterns "
 "in Rust."
 msgstr "패턴에 관한 설명은 [패턴 매칭](../pattern-matching.md)을 참조하세요."
 
-#: src/control-flow/if-let-expressions.md:21
 #: src/control-flow/if-let-expressions.md:23
 msgid ""
-"`if let` can be more concise than `match`, e.g., when only one case is "
-"interesting. In contrast, `match` requires all branches to be covered."
+"Unlike `match`, `if let` does not have to cover all branches. This can make "
+"it more concise than `match`."
 msgstr ""
-"`if let`은 `match`보다 더 간결할 수 있습니다. 예를 들어 특정한 경우만 고려하"
-"고 싶더라도 `match`는 모든 분기를 포함해야 합니다."
+"`if let`이 `match`보다 더 간결할 수 있습니다(예: 한가지 브랜치만 흥미로운 경"
+"우). 이와 달리 `match`에서는 모든 브랜치가 처리되어야 합니다."
 
-#: src/control-flow/if-let-expressions.md:22
-msgid ""
-"For the similar use case consider demonstrating a newly stabilized [`let "
-"else`](https://github.com/rust-lang/rust/pull/93628) feature."
-msgstr ""
-"비슷한 사용례로 새롭게 \"stable\" 릴리즈 된 [`let else`](https://github.com/"
-"rust-lang/rust/pull/93628) 기능을 시연하는 것도 고려해 보시기 바랍니다."
-
-#: src/control-flow/if-let-expressions.md:23
 #: src/control-flow/if-let-expressions.md:24
 msgid "A common usage is handling `Some` values when working with `Option`."
-msgstr ""
-"일반적으로 `Option`으로 작업할 때 `Some` 값을 처리하는 식으로 사용됩니다."
+msgstr "일반적 사용법은 `Option`을 사용할 때 `Some` 값을 처리하는 것입니다."
 
-#: src/control-flow/if-let-expressions.md:24
 #: src/control-flow/if-let-expressions.md:25
 msgid ""
 "Unlike `match`, `if let` does not support guard clauses for pattern matching."
-msgstr "`match`와 다르게 `if let` 패턴 매칭에서는 가드를 지원하지 않습니다."
+msgstr ""
+"`match`와 달리 `if let`은 패턴 일치를 위한 보호 절을 지원하지 않습니다."
+
+#: src/control-flow/if-let-expressions.md:26
+msgid ""
+"Since 1.65, a similar [let-else](https://doc.rust-lang.org/rust-by-example/"
+"flow_control/let_else.html) construct allows to do a destructuring "
+"assignment, or if it fails, execute a block which is required to abort "
+"normal control flow (with `panic`/`return`/`break`/`continue`):"
+msgstr ""
+"1.65부터 유사한 [let-else](https://doc.rust-lang.org/rust-by-example/"
+"flow_control/let_else.html) 구성은 디스트럭처링 할당을 실행하거나 실패할 경"
+"우 반환되지 않는 블록 브랜치(panic/return/break/continue)를 보유하도록 허용합"
+"니다:"
+
+#: src/control-flow/if-let-expressions.md:28
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    println!(\"{:?}\", second_word_to_upper(\"foo bar\"));\n"
+"}\n"
+" \n"
+"fn second_word_to_upper(s: &str) -> Option<String> {\n"
+"    let mut it = s.split(' ');\n"
+"    let (Some(_), Some(item)) = (it.next(), it.next()) else {\n"
+"        return None;\n"
+"    };\n"
+"    Some(item.to_uppercase())\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    println!(\"{:?}\", second_word_to_upper(\"foo bar\"));\n"
+"}\n"
+" \n"
+"fn second_word_to_upper(s: &str) -> Option<String> {\n"
+"    let mut it = s.split(' ');\n"
+"    let (Some(_), Some(item)) = (it.next(), it.next()) else {\n"
+"        return None;\n"
+"    };\n"
+"    Some(item.to_uppercase())\n"
+"}\n"
+"```"
 
 #: src/control-flow/while-expressions.md:1
-msgid "`while` expressions"
-msgstr "`while` 표현식"
+msgid "`while` loops"
+msgstr "`while` 반복문"
 
 #: src/control-flow/while-expressions.md:3
-msgid "The `while` keyword works very similar to other languages:"
-msgstr "`while` 역시 다른 언어과 매우 비슷합니다:"
+msgid ""
+"The [`while` keyword](https://doc.rust-lang.org/reference/expressions/loop-"
+"expr.html#predicate-loops) works very similar to other languages:"
+msgstr ""
+"[`while` 키워드](https://doc.rust-lang.org/reference/expressions/loop-expr."
+"html#predicate-loops)는 다른 언어와 매우 비슷하게 작동합니다:"
 
 #: src/control-flow/while-expressions.md:6
 msgid ""
@@ -8128,14 +9214,17 @@ msgstr ""
 "```"
 
 #: src/control-flow/while-let-expressions.md:1
-msgid "`while let` expressions"
-msgstr "`while let` 표현식"
+msgid "`while let` loops"
+msgstr "`while let` 반복문"
 
 #: src/control-flow/while-let-expressions.md:3
 msgid ""
-"Like with `if`, there is a `while let` variant which repeatedly tests a "
-"value against a pattern:"
-msgstr "`if`와 동일하게 `while let`구문 역시 패턴매칭에 사용 할 수 있습니다:"
+"Like with `if let`, there is a [`while let`](https://doc.rust-lang.org/"
+"reference/expressions/loop-expr.html#predicate-pattern-loops) variant which "
+"repeatedly tests a value against a pattern:"
+msgstr ""
+"마지막으로, 무한 루프를 만드는 [`loop` 키워드](https://doc.rust-lang.org/"
+"reference/expressions/loop-expr.html#infinite-loops)가 있습니다:"
 
 #: src/control-flow/while-let-expressions.md:6
 msgid ""
@@ -8163,7 +9252,7 @@ msgstr ""
 
 #: src/control-flow/while-let-expressions.md:17
 msgid ""
-"Here the iterator returned by `v.iter()` will return a `Option<i32>` on "
+"Here the iterator returned by `v.into_iter()` will return a `Option<i32>` on "
 "every call to `next()`. It returns `Some(x)` until it is done, after which "
 "it will return `None`. The `while let` lets us keep iterating through all "
 "items."
@@ -8172,13 +9261,13 @@ msgstr ""
 "환합니다. 반복자가 완료될 때까지는 `Some(x)`를 반환하고 마지막엔 `None`을 반"
 "환합니다. `while let`을 통해 반복자의 모든 아이템을 확인할 수 있습니다."
 
-#: src/control-flow/while-let-expressions.md:27
+#: src/control-flow/while-let-expressions.md:26
 msgid ""
 "Point out that the `while let` loop will keep going as long as the value "
 "matches the pattern."
 msgstr "`while let`은 값이 패턴에 매치되는 동안 계속됩니다."
 
-#: src/control-flow/while-let-expressions.md:28
+#: src/control-flow/while-let-expressions.md:27
 msgid ""
 "You could rewrite the `while let` loop as an infinite loop with an if "
 "statement that breaks when there is no value to unwrap for `iter.next()`. "
@@ -8189,19 +9278,19 @@ msgstr ""
 "법적 편의를 제공합니다."
 
 #: src/control-flow/for-expressions.md:1
-msgid "`for` expressions"
-msgstr "`for` 표현식"
+msgid "`for` loops"
+msgstr "`for` 반복문"
 
 #: src/control-flow/for-expressions.md:3
 msgid ""
-"The `for` expression is closely related to the `while let` expression. It "
-"will automatically call `into_iter()` on the expression and then iterate "
-"over it:"
+"The [`for` loop](https://doc.rust-lang.org/std/keyword.for.html) is closely "
+"related to the [`while let` loop](while-let-expressions.md). It will "
+"automatically call `into_iter()` on the expression and then iterate over it:"
 msgstr ""
-"`for`표현식은 `while let` 표현식과 매우 유사합니다. `for`표현식은 자동으로 "
+"`for` 반복문은 `while let` 반복문과 매우 유사합니다. `for` 반복문은 자동으로 "
 "`into_iter()`를 호출한 다음 이를 반복합니다:"
 
-#: src/control-flow/for-expressions.md:6
+#: src/control-flow/for-expressions.md:7
 msgid ""
 "```rust,editable\n"
 "fn main() {\n"
@@ -8231,27 +9320,27 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/control-flow/for-expressions.md:20
+#: src/control-flow/for-expressions.md:21
 msgid "You can use `break` and `continue` here as usual."
 msgstr "다른 언어와 마찬가지로 `break` 와 `continue`를 사용할 수 있습니다."
 
-#: src/control-flow/for-expressions.md:24
-msgid "Index iteration is not a special syntax in Rust for just that case."
-msgstr "러스트는 인덱스 반복을 위해 별도의 문법을 사용하지 않습니다. "
-
 #: src/control-flow/for-expressions.md:25
+msgid "Index iteration is not a special syntax in Rust for just that case."
+msgstr "러스트는 인덱스 기반의 반복을 위한 별도의 문법을 사용하지 않습니다."
+
+#: src/control-flow/for-expressions.md:26
 msgid "`(0..10)` is a range that implements an `Iterator` trait. "
 msgstr "`(0..10)`은 `Iterator` 트레잇을 구현하는 범위(range) 값입니다. "
 
-#: src/control-flow/for-expressions.md:26
+#: src/control-flow/for-expressions.md:27
 msgid ""
 "`step_by` is a method that returns another `Iterator` that skips every other "
 "element. "
 msgstr ""
 "`step_by`는 반복자의 요소들을 건너뛰는 또다른 `Iterator`를 반환하는 메서드입"
-"니다."
+"니다. "
 
-#: src/control-flow/for-expressions.md:27
+#: src/control-flow/for-expressions.md:28
 msgid ""
 "Modify the elements in the vector and explain the compiler errors. Change "
 "vector `v` to be mutable and the for loop to `for x in v.iter_mut()`."
@@ -8265,11 +9354,15 @@ msgstr "`loop` 표현식"
 
 #: src/control-flow/loop-expressions.md:3
 msgid ""
-"Finally, there is a `loop` keyword which creates an endless loop. Here you "
-"must either `break` or `return` to stop the loop:"
+"Finally, there is a [`loop` keyword](https://doc.rust-lang.org/reference/"
+"expressions/loop-expr.html#infinite-loops) which creates an endless loop."
 msgstr ""
-"마지막으로 `loop`키워드는 무한 루프를 생성합니다. 따라서 반드시 `break` 또는 "
-"`return`을 사용해서 루프를 정지해야 합니다:"
+"마지막으로, 무한 루프를 만드는 [`loop` 키워드](https://doc.rust-lang.org/"
+"reference/expressions/loop-expr.html#infinite-loops)가 있습니다."
+
+#: src/control-flow/loop-expressions.md:6
+msgid "Here you must either `break` or `return` to stop the loop:"
+msgstr "따라서 반드시 `break` 또는 `return`을 사용해서 루프를 정지해야 합니다:"
 
 #: src/control-flow/loop-expressions.md:8
 msgid ""
@@ -8307,11 +9400,19 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/control-flow/loop-expressions.md:25
 #: src/control-flow/loop-expressions.md:27
 msgid "Break the `loop` with a value (e.g. `break 8`) and print it out."
+msgstr "`loop`를 값(예: `break 8`)으로 나누고 출력합니다."
+
+#: src/control-flow/loop-expressions.md:28
+msgid ""
+"Note that `loop` is the only looping construct which returns a non-trivial "
+"value. This is because it's guaranteed to be entered at least once (unlike "
+"`while` and `for` loops)."
 msgstr ""
-"`loop` 블록을 빠져나올 때 `break 8`처럼 값을 지정하고 그걸 출력해보세요."
+"`loop`는 non-trivial 값을 반환하는 유일한 반복문입니다. 이는 `while` 및 "
+"`for` 반복문과 달리 최소한 한 번은 루프문을 수행하는 것이 보장되기 때문입니"
+"다."
 
 #: src/control-flow/match-expressions.md:1
 msgid "`match` expressions"
@@ -8319,13 +9420,14 @@ msgstr "`match` 표현식"
 
 #: src/control-flow/match-expressions.md:3
 msgid ""
-"The `match` keyword is used to match a value against one or more patterns. "
-"In that sense, it works like a series of `if let` expressions:"
+"The [`match` keyword](https://doc.rust-lang.org/reference/expressions/match-"
+"expr.html) is used to match a value against one or more patterns. In that "
+"sense, it works like a series of `if let` expressions:"
 msgstr ""
 "`match`키워드는 어떤 값을 하나 이상의 패턴에 대해 매치하는데 사용합니다. 그"
 "런 면에서 `if let` 표현식을 여러개 이어 놓은 것과 같습니다:"
 
-#: src/control-flow/match-expressions.md:6
+#: src/control-flow/match-expressions.md:7
 msgid ""
 "```rust,editable\n"
 "fn main() {\n"
@@ -8353,7 +9455,7 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/control-flow/match-expressions.md:19
+#: src/control-flow/match-expressions.md:20
 msgid ""
 "Like `if let`, each match arm must have the same type. The type is the last "
 "expression of the block, if any. In the example above, the type is `()`."
@@ -8362,15 +9464,15 @@ msgstr ""
 "이라면 블록의 마지막 표현식이 그 타입이 됩니다. 위의 예제에서 매치 표현식의 "
 "타입은 `()`입니다."
 
-#: src/control-flow/match-expressions.md:27
+#: src/control-flow/match-expressions.md:28
 msgid "Save the match expression to a variable and print it out."
 msgstr "`match` 표현식을 변수에 할당하고 그 값을 출력해보세요."
 
-#: src/control-flow/match-expressions.md:28
+#: src/control-flow/match-expressions.md:29
 msgid "Remove `.as_deref()` and explain the error."
 msgstr "`.as_deref()`를 지워보고, 이 때 나오는 에러를 설명해주세요."
 
-#: src/control-flow/match-expressions.md:29
+#: src/control-flow/match-expressions.md:30
 msgid ""
 "`std::env::args().next()` returns an `Option<String>`, but we cannot match "
 "against `String`."
@@ -8378,7 +9480,7 @@ msgstr ""
 "`std::env::args().next()`는 `Option<String>` 값을 반환하는데, `String`은 직"
 "접 매치할 수 없습니다."
 
-#: src/control-flow/match-expressions.md:30
+#: src/control-flow/match-expressions.md:31
 msgid ""
 "`as_deref()` transforms an `Option<T>` to `Option<&T::Target>`. In our case, "
 "this turns `Option<String>` into `Option<&str>`."
@@ -8386,7 +9488,7 @@ msgstr ""
 "`as_deref()`는 `Option<T>`를 `Option<&T::Target>`으로 바꿔줍니다. 이 경우는 "
 "`Option<String>`에서 `Option<&str>`로 바뀝니다."
 
-#: src/control-flow/match-expressions.md:31
+#: src/control-flow/match-expressions.md:32
 msgid ""
 "We can now use pattern matching to match against the `&str` inside `Option`."
 msgstr "이제는 패턴 매칭으로 `Option` 안의 `&str`을 매치할 수 있습니다."
@@ -8397,14 +9499,29 @@ msgstr "`break`와 `continue`"
 
 #: src/control-flow/break-continue.md:3
 msgid ""
-"If you want to exit a loop early, use `break`, if you want to immediately "
-"start the next iteration use `continue`. Both `continue` and `break` can "
-"optionally take a label argument which is used to break out of nested loops:"
+"If you want to exit a loop early, use [`break`](https://doc.rust-lang.org/"
+"reference/expressions/loop-expr.html#break-expressions),"
+msgstr ""
+"루프를 조기에 종료하려면 [`break`](https://doc.rust-lang.org/reference/"
+"expressions/loop-expr.html#break-expressions)를 사용합니다,"
+
+#: src/control-flow/break-continue.md:4
+msgid ""
+"If you want to immediately start the next iteration use [`continue`](https://"
+"doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions)."
+msgstr ""
+"다음 반복을 즉시 시작하려면 [`continue`](https://doc.rust-lang.org/reference/"
+"expressions/loop-expr.html#continue-expressions)를 사용합니다."
+
+#: src/control-flow/break-continue.md:7
+msgid ""
+"Both `continue` and `break` can optionally take a label argument which is "
+"used to break out of nested loops:"
 msgstr ""
 "루프를 빠져나가려면 `break`를, 다음 반복으로 넘어가기 위해서는 `continue`를 "
 "사용합니다. 중첩 루프에서는 레이블과 함께 사용할 수 있습니다:"
 
-#: src/control-flow/break-continue.md:7
+#: src/control-flow/break-continue.md:10
 msgid ""
 "```rust,editable\n"
 "fn main() {\n"
@@ -8442,7 +9559,7 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/control-flow/break-continue.md:25
+#: src/control-flow/break-continue.md:28
 msgid ""
 "In this case we break the outer loop after 3 iterations of the inner loop."
 msgstr ""
@@ -8506,7 +9623,7 @@ msgid ""
 "`alloc` and `std`. "
 msgstr ""
 "사실, 러스트의 표준 라이브러리는 `core`, `alloc`, `std`와 같이 계층(layer)으"
-"로 나눠집니다."
+"로 나눠집니다. "
 
 #: src/std.md:26
 msgid ""
@@ -8514,7 +9631,7 @@ msgid ""
 "`libc`, allocator or even the presence of an operating system. "
 msgstr ""
 "`core`는 `libc`나 할당자(allocator), 심지어 OS에도 의존하지 않는 가장 기본적"
-"인 함수와 타입을 포함합니다."
+"인 함수와 타입을 포함합니다. "
 
 #: src/std.md:28
 msgid ""
@@ -8681,7 +9798,7 @@ msgstr ""
 msgid ""
 "When people refer to strings they could either be talking about `&str` or "
 "`String`."
-msgstr "문자열이라고 언급하는 경우는 `&str`이거나 `String`일 수 있습니다."
+msgstr "사람들이 문자열이라고 말할 때에는 `&str`이거나 `String`일 수 있습니다."
 
 #: src/std/string.md:34
 msgid ""
@@ -8714,14 +9831,24 @@ msgstr ""
 "다."
 
 #: src/std/string.md:38
+msgid "Compare the different ways to index a `String`:"
+msgstr "`String`을 인덱스로 접근하는 방법들을 비교해보세요:"
+
+#: src/std/string.md:39
 msgid ""
-"Compare the different ways to index a `String` by using `s3[i]` and `s3."
-"chars().nth(i).unwrap()` where `i` is in-bound, out-of-bounds, and \"on\" "
-"the flag Unicode character."
+"To a character by using `s3.chars().nth(i).unwrap()` where `i` is in-bound, "
+"out-of-bounds."
 msgstr ""
-"`String`을 인덱스로 접근하는 방법들을 비교해보세요. `s3[i]`와 `s3.chars()."
-"nth(i).unwrap()` 방법에 대해 `i`값이 범위를 벗어날 때, 벗어나지 않을 때, 혹"
-"은 플래그 유니코드 문자에 딱 걸린 경우 등을 비교 설명해주세요."
+"`s3.chars().nth(i).unwrap()`를 이용하여 한 문자를 선택하는 경우, `i`값이 범위"
+"를 벗어날 때, 벗어나지 않을 때 동작을 설명하세요."
+
+#: src/std/string.md:40
+msgid ""
+"To a substring by using `s3[0..4]`, where that slice is on character "
+"boundaries or not."
+msgstr ""
+"`s3[0..4]`를 이용해서 문자열의 일부를 선택하는데, 슬라이스가 유니코드 문자열 "
+"경계에 딱 맞지 않을 경우 어떻게 되는지 설명하세요."
 
 #: src/std/vec.md:1
 msgid "`Vec`"
@@ -9014,6 +10141,18 @@ msgstr ""
 "예제 코드에서 `to_string()`을 없애도 컴파일에 문제가 없는지 확인해보세요. 어"
 "떤 문제에 부딪힐까요?"
 
+#: src/std/hashmap.md:64
+msgid ""
+"This type has several \"method-specific\" return types, such as `std::"
+"collections::hash_map::Keys`. These types often appear in searches of the "
+"Rust docs. Show students the docs for this type, and the helpful link back "
+"to the `keys` method."
+msgstr ""
+"해시맵의 몇 몇 메서드는 해시맵 내부의 특별한 타입(예를 들어 `std::"
+"collections::hash_map::Keys`)들을 리턴합니다. 이러한 타입들은 Rust 문서에서"
+"도 검색할 수 있습니다. 수강생들에게 이 타입들에 대한 문서를 보여주고, 이 문서"
+"에 `keys` 메서드로의 역 링크가 있음을 알려주세요."
+
 #: src/std/box.md:1
 msgid "`Box`"
 msgstr "`Box`"
@@ -9087,14 +10226,14 @@ msgid ""
 "not null. "
 msgstr ""
 "`Box`는 C++의 `std::unique_ptr`과 비슷합니다. 차이라면 `Box`는 널이 아님을 보"
-"장한다는 점입니다."
+"장한다는 점입니다. "
 
 #: src/std/box.md:35
 msgid ""
 "In the above example, you can even leave out the `*` in the `println!` "
 "statement thanks to `Deref`. "
 msgstr ""
-"`Deref` 덕분에 위 예제의 `println!`문에 사용된 `*`를 빼도 문제가 없습니다."
+"`Deref` 덕분에 위 예제의 `println!`문에 사용된 `*`를 빼도 문제가 없습니다. "
 
 #: src/std/box.md:36
 msgid "A `Box` can be useful when you:"
@@ -9196,9 +10335,9 @@ msgstr ""
 
 #: src/std/box-recursive.md:33
 msgid ""
-"If the `Box` was not used here and we attempted to embed a `List` directly "
-"into the `List`, the compiler would not compute a fixed size of the struct "
-"in memory, it would look infinite."
+"If `Box` was not used and we attempted to embed a `List` directly into the "
+"`List`, the compiler would not compute a fixed size of the struct in memory "
+"(`List` would be of infinite size)."
 msgstr ""
 "만일 `Box`를 사용하지 않고 `List`에 직접 `List`를 포함하려고 시도한다면, 컴파"
 "일러는 구조체의 고정 크기를 계산할 수 없습니다. 컴파일러가 보기에 무한대의 크"
@@ -9290,7 +10429,7 @@ msgid ""
 "\n"
 "fn main() {\n"
 "    let mut a = Rc::new(10);\n"
-"    let mut b = a.clone();\n"
+"    let mut b = Rc::clone(&a);\n"
 "\n"
 "    println!(\"a: {a}\");\n"
 "    println!(\"b: {b}\");\n"
@@ -9302,7 +10441,7 @@ msgstr ""
 "\n"
 "fn main() {\n"
 "    let mut a = Rc::new(10);\n"
-"    let mut b = a.clone();\n"
+"    let mut b = Rc::clone(&a);\n"
 "\n"
 "    println!(\"a: {a}\");\n"
 "    println!(\"b: {b}\");\n"
@@ -9311,53 +10450,46 @@ msgstr ""
 
 #: src/std/rc.md:18
 msgid ""
-"If you need to mutate the data inside an `Rc`, you will need to wrap the "
-"data in a type such as [`Cell` or `RefCell`](../concurrency/shared_state/arc."
-"md)."
+"See [`Arc`](../concurrency/shared_state/arc.md) and [`Mutex`](https://doc."
+"rust-lang.org/std/sync/struct.Mutex.html) if you are in a multi-threaded "
+"context."
 msgstr ""
-"`Rc`내부의 데이터를 변경해야 하는 경우, 데이터를 [`Cell` 또는 `RefCell`](../"
-"concurrency/shared_state/arc.md)로 래핑해야합니다."
+"멀티스레드 환경에서 작업하는 경우 [`Arc`](../concurrency/shared_state/arc.md)"
+"와 [`Mutex`](https://doc.rust-lang.org/std/sync/struct.Mutex.html)를 참조하세"
+"요."
 
-#: src/std/rc.md:20
-msgid ""
-"See [`Arc`](https://doc.rust-lang.org/std/sync/struct.Mutex.html) if you are "
-"in a multi-threaded context."
-msgstr ""
-"멀티스레드인 경우 [`Arc`](https://doc.rust-lang.org/std/sync/struct.Mutex."
-"html)를 참조하시기 바랍니다."
-
-#: src/std/rc.md:21
+#: src/std/rc.md:19
 msgid ""
 "You can _downgrade_ a shared pointer into a [`Weak`](https://doc.rust-lang."
 "org/std/rc/struct.Weak.html) pointer to create cycles that will get dropped."
 msgstr ""
 "drop 가능한 순환 구조를 만들기 위해 공유 포인터를 [`Weak`](https://doc.rust-"
-"lang.org/std/rc/struct.Weak.html) 포인터로 **다운그레이드**할 수도 있습니다."
+"lang.org/std/rc/struct.Weak.html) 포인터로 _다운그레이드_할 수도 있습니다."
 
-#: src/std/rc.md:31
+#: src/std/rc.md:29
 msgid ""
-"`Rc`'s Count ensures that its contained value is valid for as long as there "
+"`Rc`'s count ensures that its contained value is valid for as long as there "
 "are references."
 msgstr ""
 "`Rc`는 참조 카운트를 통해 참조가 있는 동안은 `Rc`가 가리키고 있는 값이 메모리"
 "에서 해제되지 않음을 보장합니다."
 
-#: src/std/rc.md:32
-msgid "Like C++'s `std::shared_ptr`."
+#: src/std/rc.md:30
+msgid "`Rc` in Rust is like `std::shared_ptr` in C++."
 msgstr "C++의 `std::shared_ptr`와 유사합니다."
 
-#: src/std/rc.md:33
+#: src/std/rc.md:31
 msgid ""
-"`clone` is cheap: it creates a pointer to the same allocation and increases "
-"the reference count. Does not make a deep clone and can generally be ignored "
-"when looking for performance issues in code."
+"`Rc::clone` is cheap: it creates a pointer to the same allocation and "
+"increases the reference count. Does not make a deep clone and can generally "
+"be ignored when looking for performance issues in code."
 msgstr ""
-"`clone`은 저렴합니다. 같은 곳을 가리키는 포인터를 하나 더 만들고, 참조 카운트"
-"를 늘립니다. 포인터가 가리키는 값 자체가 복제(깊은 복제)되지는 않으며, 그래"
-"서 코드에서 성능 문제가 있는지 검토할 때 일반적으로 `Rc`를 `clone`하는 것은 "
-"무시할 수 있습니다."
+"`clone`은 비용이 거의 들지 않습니다. 같은 곳을 가리키는 포인터를 하나 더 만들"
+"고, 참조 카운트를 늘립니다. 포인터가 가리키는 값 자체가 복제(깊은 복제)되지"
+"는 않으며, 그래서 코드에서 성능 문제가 있는지 검토할 때 일반적으로 `Rc`를 "
+"`clone`하는 것은 무시할 수 있습니다."
 
-#: src/std/rc.md:34
+#: src/std/rc.md:32
 msgid ""
 "`make_mut` actually clones the inner value if necessary (\"clone-on-write\") "
 "and returns a mutable reference."
@@ -9365,88 +10497,158 @@ msgstr ""
 "`make_mut`는 실제로 필요한 경우에 내부 값을 복제하고(\"clone-on-write\") 가"
 "변 참조를 반환합니다."
 
-#: src/std/rc.md:35
+#: src/std/rc.md:33
 msgid "Use `Rc::strong_count` to check the reference count."
 msgstr "참조 카운트를 확인하려면 `Rc::strong_count`를 사용하세요."
 
-#: src/std/rc.md:36
+#: src/std/rc.md:34
 msgid ""
-"Compare the different datatypes mentioned. `Box` enables (im)mutable borrows "
-"that are enforced at compile time. `RefCell` enables (im)mutable borrows "
-"that are enforced at run time and will panic if it fails at runtime."
+"`Rc::downgrade` gives you a _weakly reference-counted_ object to create "
+"cycles that will be dropped properly (likely in combination with `RefCell`, "
+"on the next slide)."
 msgstr ""
-"여기 언급된 몇가지 데이터 타입을 비교해보세요. `Box`는 불변/가변 빌림(borrow)"
-"을 컴파일 시점에 강제합니다. `RefCell`은 실행 시점에 불변/가변 빌림을 강제하"
-"며, 만약 런타임 시에 빌림 문제가 발생하면 패닉을 일으킵니다."
+"`Rc`는 `downgrade()`로 다운그레이드하여 _약하게 참조 카운트되는(weekly "
+"reference-counted)_ 객체가 될 있습니다. 그러면 순환구조라 하더라도 drop이 가"
+"능합니다. (아마도 `RefCell` 을 함께 사용해야 할 것입니다.)"
 
-#: src/std/rc.md:37
+#: src/std/cell.md:1
+msgid "`Cell` and `RefCell`"
+msgstr "`Cell`과 `RefCell`"
+
+#: src/std/cell.md:3
 msgid ""
-"You can `downgrade()` a `Rc` into a _weakly reference-counted_ object to "
-"create cycles that will be dropped properly (likely in combination with "
-"`RefCell`)."
+"\\[`Cell`\\]\\[https://doc.rust-lang.org/std/cell/struct.Cell.html\\] and "
+"[`RefCell`](https://doc.rust-lang.org/std/cell/struct.RefCell.html) "
+"implement what Rust calls _interior mutability:_ mutation of values in an "
+"immutable context."
 msgstr ""
-"`Rc`는 `downgrade()`로 다운그레이드하여 **weak 참조 카운트**로 변경할 수 있습"
-"니다. 그러면 순환구조라 하더라도 drop이 가능합니다. (아마도 `RefCell` 을 함"
-"께 사용해야 할 것입니다.)"
+"[`Cell`](https://doc.rust-lang.org/std/cell/struct.Cell.html 과 [`RefCell`]"
+"(https://doc.rust-lang.org/std/cell/struct.RefCell.html)은 러스트에서 _내적 "
+"가변성(interior mutability)_이라고 부르는 것을 구현합니다. 이를 이용하면 불변"
+"인 객체의 값을 수정할 수 있습니다."
 
-#: src/std/rc.md:41
+#: src/std/cell.md:8
+msgid ""
+"`Cell` is typically used for simple types, as it requires copying or moving "
+"values. More complex interior types typically use `RefCell`, which tracks "
+"shared and exclusive references at runtime and panics if they are misused."
+msgstr ""
+"`Cell`은 간단한 타입에 대해서 주로 사용됩니다. 왜냐하면 `Cell`에 있는 값을 읽"
+"거나 쓸때에는 복사 혹은 이동을 해야만 하기 때문입니다. 복잡한 타입이라면 "
+"`RefCell`이 더 보편적입니다. 이를 이용하면 참조를 통해 값을 읽거나 쓰게 해 주"
+"는 대신, 그 참조들이 올바른지를 런타임에 체크하고, 제대로 사용되지 않을 경우 "
+"패닉을 발생시킵니다."
+
+#: src/std/cell.md:12
 msgid ""
 "```rust,editable\n"
-"use std::rc::{Rc, Weak};\n"
 "use std::cell::RefCell;\n"
+"use std::rc::Rc;\n"
 "\n"
-"#[derive(Debug)]\n"
+"#[derive(Debug, Default)]\n"
 "struct Node {\n"
 "    value: i64,\n"
-"    parent: Option<Weak<RefCell<Node>>>,\n"
 "    children: Vec<Rc<RefCell<Node>>>,\n"
 "}\n"
 "\n"
+"impl Node {\n"
+"    fn new(value: i64) -> Rc<RefCell<Node>> {\n"
+"        Rc::new(RefCell::new(Node { value, ..Node::default() }))\n"
+"    }\n"
+"\n"
+"    fn sum(&self) -> i64 {\n"
+"        self.value + self.children.iter().map(|c| c.borrow().sum()).sum::"
+"<i64>()\n"
+"    }\n"
+"}\n"
+"\n"
 "fn main() {\n"
-"    let mut root = Rc::new(RefCell::new(Node {\n"
-"        value: 42,\n"
-"        parent: None,\n"
-"        children: vec![],\n"
-"    }));\n"
-"    let child = Rc::new(RefCell::new(Node {\n"
-"        value: 43,\n"
-"        children: vec![],\n"
-"        parent: Some(Rc::downgrade(&root))\n"
-"    }));\n"
-"    root.borrow_mut().children.push(child);\n"
+"    let root = Node::new(1);\n"
+"    root.borrow_mut().children.push(Node::new(5));\n"
+"    let subtree = Node::new(10);\n"
+"    subtree.borrow_mut().children.push(Node::new(11));\n"
+"    subtree.borrow_mut().children.push(Node::new(12));\n"
+"    root.borrow_mut().children.push(subtree);\n"
 "\n"
 "    println!(\"graph: {root:#?}\");\n"
+"    println!(\"graph sum: {}\", root.borrow().sum());\n"
 "}\n"
 "```"
 msgstr ""
 "```rust,editable\n"
-"use std::rc::{Rc, Weak};\n"
 "use std::cell::RefCell;\n"
+"use std::rc::Rc;\n"
 "\n"
-"#[derive(Debug)]\n"
+"#[derive(Debug, Default)]\n"
 "struct Node {\n"
 "    value: i64,\n"
-"    parent: Option<Weak<RefCell<Node>>>,\n"
 "    children: Vec<Rc<RefCell<Node>>>,\n"
 "}\n"
 "\n"
+"impl Node {\n"
+"    fn new(value: i64) -> Rc<RefCell<Node>> {\n"
+"        Rc::new(RefCell::new(Node { value, ..Node::default() }))\n"
+"    }\n"
+"\n"
+"    fn sum(&self) -> i64 {\n"
+"        self.value + self.children.iter().map(|c| c.borrow().sum()).sum::"
+"<i64>()\n"
+"    }\n"
+"}\n"
+"\n"
 "fn main() {\n"
-"    let mut root = Rc::new(RefCell::new(Node {\n"
-"        value: 42,\n"
-"        parent: None,\n"
-"        children: vec![],\n"
-"    }));\n"
-"    let child = Rc::new(RefCell::new(Node {\n"
-"        value: 43,\n"
-"        children: vec![],\n"
-"        parent: Some(Rc::downgrade(&root))\n"
-"    }));\n"
-"    root.borrow_mut().children.push(child);\n"
+"    let root = Node::new(1);\n"
+"    root.borrow_mut().children.push(Node::new(5));\n"
+"    let subtree = Node::new(10);\n"
+"    subtree.borrow_mut().children.push(Node::new(11));\n"
+"    subtree.borrow_mut().children.push(Node::new(12));\n"
+"    root.borrow_mut().children.push(subtree);\n"
 "\n"
 "    println!(\"graph: {root:#?}\");\n"
+"    println!(\"graph sum: {}\", root.borrow().sum());\n"
 "}\n"
 "```"
 
+#: src/std/cell.md:47
+msgid ""
+"If we were using `Cell` instead of `RefCell` in this example, we would have "
+"to move the `Node` out of the `Rc` to push children, then move it back in. "
+"This is safe because there's always one, un-referenced value in the cell, "
+"but it's not ergonomic."
+msgstr ""
+"이 예제에서 `RefCell`대신 `Cell`을 썼었다면, `Node`에 자식 노느를 추가하기 위"
+"해서, `Node`를 `Rc`밖으로 이동시킨 다음, 자식 노드를 추가하고, 다시 `Rc`안으"
+"로 이동시켜야 했을 겁니다. 이렇게 해야만 하는 이유는 안전 때문입니다. Cell 내"
+"부의 그 값이 오직 하나 존재하며, 그 값에 대한 참조가 없다는 것이 보장되기 때"
+"문입니다. 물론 편리하지는 않습니다."
+
+#: src/std/cell.md:48
+msgid ""
+"To do anything with a Node, you must call a `RefCell` method, usually "
+"`borrow` or `borrow_mut`."
+msgstr ""
+"노드를 이동하거나 복사하지 않고 그대로 사용하기 위해서는 `RefCell`로 감싼다"
+"음 `borrow`나 `borrow_mut`메서드를 이용해야 합니다."
+
+#: src/std/cell.md:49
+msgid ""
+"Demonstrate that reference loops can be created by adding `root` to `subtree."
+"children` (don't try to print it!)."
+msgstr ""
+"`root`를 `subtree.children`에 추가해서 순환 참조가 생길 수 있음을 보여주세요 "
+"(그래프를 출력하지는 마세요!)."
+
+#: src/std/cell.md:50
+msgid ""
+"To demonstrate a runtime panic, add a `fn inc(&mut self)` that increments "
+"`self.value` and calls the same method on its children. This will panic in "
+"the presence of the reference loop, with `thread 'main' panicked at 'already "
+"borrowed: BorrowMutError'`."
+msgstr ""
+"`self.value`를 증가시키는 메서드인`fn inc(&mut self)`를 추가하고 그 메서드를 "
+"자식노드에서 호출하세요. 그러면 `thread 'main' panicked at 'already "
+"borrowed: BorrowMutError'` 런타임 패닉이 발생함을 보이세요."
+
 #: src/modules.md:3
 msgid "We have seen how `impl` blocks let us namespace functions to a type."
 msgstr "`impl`블록은 해당 타입의 함수들에 대한 네임스페이스를 제공합니다."
@@ -9633,11 +10835,11 @@ msgstr "경로는 아래와 같이 구분합니다:"
 
 #: src/modules/paths.md:5
 msgid "As a relative path:"
-msgstr "상대 경로"
+msgstr "상대 경로:"
 
 #: src/modules/paths.md:6
 msgid "`foo` or `self::foo` refers to `foo` in the current module,"
-msgstr "`foo` 또는 `self::foo`는 현재 모듈 내부의 `foo`를 가리킵니다."
+msgstr "`foo` 또는 `self::foo`는 현재 모듈 내부의 `foo`를 가리킵니다,"
 
 #: src/modules/paths.md:7
 msgid "`super::foo` refers to `foo` in the parent module."
@@ -9645,11 +10847,11 @@ msgstr "`super::foo`는 부모 모듈의 `foo`를 가리킵니다."
 
 #: src/modules/paths.md:9
 msgid "As an absolute path:"
-msgstr "절대 경로"
+msgstr "절대 경로:"
 
 #: src/modules/paths.md:10
 msgid "`crate::foo` refers to `foo` in the root of the current crate,"
-msgstr "`crate::foo`는 현재 크레이트 루트의 `foo`를 가리킵니다."
+msgstr "`crate::foo`는 현재 크레이트 루트의 `foo`를 가리킵니다,"
 
 #: src/modules/paths.md:11
 msgid "`bar::foo` refers to `foo` in the `bar` crate."
@@ -9661,7 +10863,7 @@ msgid ""
 "will typically see something like this at the top of each module:"
 msgstr ""
 "모듈은 `use`를 사용하여 다른 모듈의 심볼을 내 스코프로 가져올 수 있습니다. 일"
-"반적으로 각 모듈의 상단에 다음과 같은 내용이 옵니다."
+"반적으로 각 모듈의 상단에 다음과 같은 내용이 옵니다:"
 
 #: src/modules/paths.md:16
 msgid ""
@@ -9676,8 +10878,10 @@ msgstr ""
 "```"
 
 #: src/modules/filesystem.md:3
-msgid "The module content can be omitted:"
-msgstr "모듈의 내용은 생략될 수 있습니다:"
+msgid ""
+"Omitting the module content will tell Rust to look for it in another file:"
+msgstr ""
+"모듈의 내용을 기술하지 않으면, 러스트는 다른 파일에서 그 내용을 읽습니다:"
 
 #: src/modules/filesystem.md:5
 msgid ""
@@ -9690,42 +10894,28 @@ msgstr ""
 "```"
 
 #: src/modules/filesystem.md:9
-msgid "The `garden` module content is found at:"
-msgstr "`garden` 모듈의 내용은 아래 위치에서 확인 할 수 있습니다:"
-
-#: src/modules/filesystem.md:11
-msgid "`src/garden.rs` (modern Rust 2018 style)"
-msgstr "`src/garden.rs`(최신 Rust 2018 스타일)"
+msgid ""
+"This tells rust that the `garden` module content is found at `src/garden."
+"rs`. Similarly, a `garden::vegetables` module can be found at `src/garden/"
+"vegetables.rs`."
+msgstr ""
+"위 코드는 러스트로 하여금 `garden`모듈의 내용을 `src/garden.rs`에서 찾도록 합"
+"니다. 비슷하게, `garden::vegetables` 모듈은 `src/garden/vegetables.rs`에서 찾"
+"습니다."
 
 #: src/modules/filesystem.md:12
-msgid "`src/garden/mod.rs` (older Rust 2015 style)"
-msgstr "`src/garden/mod.rs`(이전 Rust 2015 스타일)"
-
-#: src/modules/filesystem.md:14
-msgid "Similarly, a `garden::vegetables` module can be found at:"
-msgstr "유사하게 `garden::vegetables` 모듈은 아래 위치에서 확인할 수 있습니다:"
-
-#: src/modules/filesystem.md:16
-msgid "`src/garden/vegetables.rs` (modern Rust 2018 style)"
-msgstr "`src/garden/vegetables.rs`(최신 Rust 2018 스타일)"
-
-#: src/modules/filesystem.md:17
-msgid "`src/garden/vegetables/mod.rs` (older Rust 2015 style)"
-msgstr "`src/garden/vegetables/mod.rs`(이전 Rust 2015 스타일)"
-
-#: src/modules/filesystem.md:19
 msgid "The `crate` root is in:"
 msgstr "`crate(크레이트)`의 루트는 아래 경로 입니다:"
 
-#: src/modules/filesystem.md:21
+#: src/modules/filesystem.md:14
 msgid "`src/lib.rs` (for a library crate)"
 msgstr "`src/lib.rs` (라이브러리 크레이트)"
 
-#: src/modules/filesystem.md:22
+#: src/modules/filesystem.md:15
 msgid "`src/main.rs` (for a binary crate)"
 msgstr "`src/main.rs` (바이너리 크레이트)"
 
-#: src/modules/filesystem.md:24
+#: src/modules/filesystem.md:17
 msgid ""
 "Modules defined in files can be documented, too, using \"inner doc "
 "comments\". These document the item that contains them -- in this case, a "
@@ -9734,74 +10924,7 @@ msgstr ""
 "모듈도 \"내부 문서 주석\"을 사용하여 문서화할 수 있습니다. 이러한 모듈은 모듈"
 "이 포함된 항목(이 경우에는 모듈)을 문서화합니다."
 
-#: src/modules/filesystem.md:26
-msgid ""
-"The change from `module/mod.rs` to `module.rs` doesn't preclude the use of "
-"submodules in Rust 2018. (It was mandatory in Rust 2015.)"
-msgstr ""
-"`module/mod.rs`를 `module.rs`로 바꾼다 하더라도 Rust 2018에서는 하위 모듈을 "
-"사용할 수 있습니다. (Rust 2015에서는 하위 모듈이 있는 모듈은 `module/mod.rs` "
-"형태여야 했습니다.)"
-
-#: src/modules/filesystem.md:29
-msgid "The following is valid:"
-msgstr "아래처럼 구성하는데 아무런 문제가 없습니다:"
-
-#: src/modules/filesystem.md:31
-msgid ""
-"```ignore\n"
-"src/\n"
-"├── main.rs\n"
-"├── top_module.rs\n"
-"└── top_module/\n"
-"    └── sub_module.rs\n"
-"```"
-msgstr ""
-"```ignore\n"
-"src/\n"
-"├── main.rs\n"
-"├── top_module.rs\n"
-"└── top_module/\n"
-"    └── sub_module.rs\n"
-"```"
-
-#: src/modules/filesystem.md:39
-msgid ""
-"The main reason for the change is to prevent many files named `mod.rs`, "
-"which can be hard to distinguish in IDEs."
-msgstr ""
-"이렇게 변경된 주된 이유는 모두 똑같은 이름의 `mod.rs` 파일이 잔뜩 생기는 것"
-"을 방지하기 위해서 입니다. IDE에서는 이들을 구분하기가 까다로웠습니다."
-
-#: src/modules/filesystem.md:42
-msgid ""
-"Rust will look for modules in `modulename/mod.rs` and `modulename.rs`, but "
-"this can be changed with a compiler directive:"
-msgstr ""
-"러스트는 모듈을 찾을 때 `modulename/mod.rs`와 `modulename.rs` 파일을 검사하는"
-"데, 컴파일러 디렉티브로 이를 변경할 수 있습니다."
-
-#: src/modules/filesystem.md:45
-msgid ""
-"```rust,ignore\n"
-"#[path = \"some/path.rs\"]\n"
-"mod some_module { }\n"
-"```"
-msgstr ""
-"```rust,ignore\n"
-"#[path = \"some/path.rs\"]\n"
-"mod some_module { }\n"
-"```"
-
-#: src/modules/filesystem.md:50
-msgid ""
-"This is useful, for example, if you would like to place tests for a module "
-"in a file named `some_module_test.rs`, similar to the convention in Go."
-msgstr ""
-"Go언어 에서처럼 어떤 모듈의 테스트를 `some_module_test.rs` 같은 파일에 두고 "
-"싶은 경우에 유용합니다."
-
-#: src/modules/filesystem.md:27
+#: src/modules/filesystem.md:20
 msgid ""
 "```rust,editable,compile_fail\n"
 "//! This module implements the garden, including a highly performant "
@@ -9834,6 +10957,73 @@ msgstr ""
 "pub fn harvest(garden: &mut Garden) { todo!() }\n"
 "```"
 
+#: src/modules/filesystem.md:37
+msgid ""
+"Before Rust 2018, modules needed to be located at `module/mod.rs` instead of "
+"`module.rs`, and this is still a working alternative for editions after 2018."
+msgstr ""
+"`module/mod.rs`를 `module.rs`로 바꾼다 하더라도 Rust 2018에서는 하위 모듈을 "
+"사용할 수 있습니다."
+
+#: src/modules/filesystem.md:39
+msgid ""
+"The main reason to introduce `filename.rs` as alternative to `filename/mod."
+"rs` was because many files named `mod.rs` can be hard to distinguish in IDEs."
+msgstr ""
+"`filename.rs`를 `filename/mod.rs`대신 사용할 수 있도록 하는 주된 이유는, "
+"`mod.rs`라는 이름을 가진 파일이 많을 경우 IDE에서 이들을 서로 구별하는게 힘들"
+"기 때문입니다."
+
+#: src/modules/filesystem.md:42
+msgid "Deeper nesting can use folders, even if the main module is a file:"
+msgstr ""
+"폴더를 이용해서 더 깊은 계층 구조를 구현할 수 있습니다. 심지어는 메인 모듈이 "
+"파일이더라도요:"
+
+#: src/modules/filesystem.md:44
+msgid ""
+"```ignore\n"
+"src/\n"
+"├── main.rs\n"
+"├── top_module.rs\n"
+"└── top_module/\n"
+"    └── sub_module.rs\n"
+"```"
+msgstr ""
+"```ignore\n"
+"src/\n"
+"├── main.rs\n"
+"├── top_module.rs\n"
+"└── top_module/\n"
+"    └── sub_module.rs\n"
+"```"
+
+#: src/modules/filesystem.md:52
+msgid ""
+"The place rust will look for modules can be changed with a compiler "
+"directive:"
+msgstr "러스트가 어디서 모듈들을 찾을지는 컴파일러 디렉티브로 변경 가능합니다:"
+
+#: src/modules/filesystem.md:54
+msgid ""
+"```rust,ignore\n"
+"#[path = \"some/path.rs\"]\n"
+"mod some_module;\n"
+"```"
+msgstr ""
+"```rust,ignore\n"
+"#[path = \"some/path.rs\"]\n"
+"mod some_module;\n"
+"```"
+
+#: src/modules/filesystem.md:59
+msgid ""
+"This is useful, for example, if you would like to place tests for a module "
+"in a file named `some_module_test.rs`, similar to the convention in Go."
+msgstr ""
+"이는 Go언어 에서처럼 어떤 모듈의 테스트를 `some_module_test.rs` 같은 파일에 "
+"두고 싶은 경우에 유용합니다."
+
 #: src/exercises/day-2/afternoon.md:1
 msgid "Day 2: Afternoon Exercises"
 msgstr "2일차 오후 연습문제"
@@ -9859,11 +11049,11 @@ msgstr "모든 공백을 무시합니다. 2자리 미만 숫자는 무시합니
 
 #: src/exercises/day-2/luhn.md:9
 msgid ""
-"Moving from right to left, double every second digit: for the number `1234`, "
-"we double `3` and `1`."
+"Moving from **right to left**, double every second digit: for the number "
+"`1234`, we double `3` and `1`. For the number `98765`, we double `6` and `8`."
 msgstr ""
-"오른쪽에서 왼쪽으로 이동하며 2번째 자리마다 숫자를 2배 증가시킵니다. 예를 들"
-"어 `1234`에서 `3`과 `1`에 각각 2를 곱합니다."
+"**오른쪽에서 왼쪽으로** 이동하며 2번째 자리마다 숫자를 2배 증가시킵니다. 예"
+"를 들어 `1234`에서 `3`과 `1`에 각각 2를 곱합니다."
 
 #: src/exercises/day-2/luhn.md:12
 msgid ""
@@ -9883,13 +11073,20 @@ msgstr "합계의 끝자리가 `0`인 경우 유효한 신용카드 번호입니
 
 #: src/exercises/day-2/luhn.md:19
 msgid ""
-"Copy the following code to <https://play.rust-lang.org/> and implement the "
-"function:"
+"Copy the code below to <https://play.rust-lang.org/> and implement the "
+"function."
 msgstr ""
-"아래 코드를 <https://play.rust-lang.org/>에 복사하고 함수를 구현해 보시기 바"
-"랍니다:"
+"아래 코드를 <https://play.rust-lang.org/>에 복사해서 구현하시면 됩니다."
 
-#: src/exercises/day-2/luhn.md:23
+#: src/exercises/day-2/luhn.md:21
+msgid ""
+"Try to solve the problem the \"simple\" way first, using `for` loops and "
+"integers. Then, revisit the solution and try to implement it with iterators."
+msgstr ""
+"`for`반복문과 인덱스를 이용하는 \"쉬운\"방법으로 먼저 풀어 보세요. 그런 다음 "
+"반복자를 이용해서 다시 풀어 보세요."
+
+#: src/exercises/day-2/luhn.md:25
 msgid ""
 "```rust\n"
 "// TODO: remove this when you're done with your implementation.\n"
@@ -9940,6 +11137,54 @@ msgid ""
 "fn main() {}\n"
 "```"
 msgstr ""
+"```rust\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_variables, dead_code)]\n"
+"\n"
+"pub fn luhn(cc_number: &str) -> bool {\n"
+"    unimplemented!()\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_non_digit_cc_number() {\n"
+"    assert!(!luhn(\"foo\"));\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_empty_cc_number() {\n"
+"    assert!(!luhn(\"\"));\n"
+"    assert!(!luhn(\" \"));\n"
+"    assert!(!luhn(\"  \"));\n"
+"    assert!(!luhn(\"    \"));\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_single_digit_cc_number() {\n"
+"    assert!(!luhn(\"0\"));\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_two_digit_cc_number() {\n"
+"    assert!(luhn(\" 0 0 \"));\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_valid_cc_number() {\n"
+"    assert!(luhn(\"4263 9826 4026 9299\"));\n"
+"    assert!(luhn(\"4539 3195 0343 6467\"));\n"
+"    assert!(luhn(\"7992 7398 713\"));\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_invalid_cc_number() {\n"
+"    assert!(!luhn(\"4223 9826 4026 9299\"));\n"
+"    assert!(!luhn(\"4539 3195 0343 6476\"));\n"
+"    assert!(!luhn(\"8273 1232 7352 0569\"));\n"
+"}\n"
+"\n"
+"#[allow(dead_code)]\n"
+"fn main() {}\n"
+"```"
 
 #: src/exercises/day-2/strings-iterators.md:3
 msgid ""
@@ -10009,6 +11254,51 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_variables, dead_code)]\n"
+"\n"
+"pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {\n"
+"    unimplemented!()\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_matches_without_wildcard() {\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/"
+"abc-123\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/abc/"
+"books\"));\n"
+"\n"
+"    assert!(!prefix_matches(\"/v1/publishers\", \"/v1\"));\n"
+"    assert!(!prefix_matches(\"/v1/publishers\", \"/v1/publishersBooks\"));\n"
+"    assert!(!prefix_matches(\"/v1/publishers\", \"/v1/parent/"
+"publishers\"));\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_matches_with_wildcard() {\n"
+"    assert!(prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/books\"\n"
+"    ));\n"
+"    assert!(prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/bar/books\"\n"
+"    ));\n"
+"    assert!(prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/books/book1\"\n"
+"    ));\n"
+"\n"
+"    assert!(!prefix_matches(\"/v1/publishers/*/books\", \"/v1/"
+"publishers\"));\n"
+"    assert!(!prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/booksByAuthor\"\n"
+"    ));\n"
+"}\n"
+"```"
 
 #: src/welcome-day-3.md:1
 msgid "Welcome to Day 3"
@@ -10050,6 +11340,201 @@ msgstr ""
 "안전하지 않은 러스트: 원시(raw) 포인터, 정적 변수, 안전하지 않은 함수, 외부 "
 "함수."
 
+#: src/generics.md:3
+msgid ""
+"Rust support generics, which lets you abstract algorithms or data structures "
+"(such as sorting or a binary tree) over the types used or stored."
+msgstr ""
+"러스트는 제네릭을 지원합니다. 이를 이용하면 알고리즘(정렬과 같은)이나 데이터 "
+"구조(이진 트리 같은)를 추상화 하여 특정 타입에 의존하지 않도록 할 수 있습니"
+"다."
+
+#: src/generics/data-types.md:3
+msgid "You can use generics to abstract over the concrete field type:"
+msgstr "제네릭을 사용하여 필드의 타입을 추상화 할 수 있습니다:"
+
+#: src/generics/data-types.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T> {\n"
+"    x: T,\n"
+"    y: T,\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let integer = Point { x: 5, y: 10 };\n"
+"    let float = Point { x: 1.0, y: 4.0 };\n"
+"    println!(\"{integer:?} and {float:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T> {\n"
+"    x: T,\n"
+"    y: T,\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let integer = Point { x: 5, y: 10 };\n"
+"    let float = Point { x: 1.0, y: 4.0 };\n"
+"    println!(\"{integer:?} and {float:?}\");\n"
+"}\n"
+"```"
+
+#: src/generics/data-types.md:21
+msgid "Try declaring a new variable `let p = Point { x: 5, y: 10.0 };`."
+msgstr "새 변수 `let p = Point { x: 5, y: 10.0 };`를 선언해 보세요."
+
+#: src/generics/data-types.md:23
+msgid "Fix the code to allow points that have elements of different types."
+msgstr ""
+"`Point`가 서로 다른 타입의 값들으로 이루어져도 컴파일 되도록 코드를 수정해 보"
+"세요."
+
+#: src/generics/methods.md:3
+msgid "You can declare a generic type on your `impl` block:"
+msgstr "`impl` 블록에서도 제네릭 타입을 선언할 수 있습니다:"
+
+#: src/generics/methods.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T>(T, T);\n"
+"\n"
+"impl<T> Point<T> {\n"
+"    fn x(&self) -> &T {\n"
+"        &self.0  // + 10\n"
+"    }\n"
+"\n"
+"    // fn set_x(&mut self, x: T)\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let p = Point(5, 10);\n"
+"    println!(\"p.x = {}\", p.x());\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T>(T, T);\n"
+"\n"
+"impl<T> Point<T> {\n"
+"    fn x(&self) -> &T {\n"
+"        &self.0  // + 10\n"
+"    }\n"
+"\n"
+"    // fn set_x(&mut self, x: T)\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let p = Point(5, 10);\n"
+"    println!(\"p.x = {}\", p.x());\n"
+"}\n"
+"```"
+
+#: src/generics/methods.md:25
+msgid ""
+"_Q:_ Why `T` is specified twice in `impl<T> Point<T> {}`? Isn't that "
+"redundant?"
+msgstr "_질문:_ `impl<T> Point<T> {}`에서 `T`가 왜 두 번 사용됩니까?"
+
+#: src/generics/methods.md:26
+msgid ""
+"This is because it is a generic implementation section for generic type. "
+"They are independently generic."
+msgstr ""
+"제네릭 타입에 대한 제네릭 구현 이기 때문입니다. 이 두 제네릭은 서로 독립적입"
+"니다."
+
+#: src/generics/methods.md:27
+msgid "It means these methods are defined for any `T`."
+msgstr ""
+"이는 임의의 모든 `T`에 대해서 이 메소드들이 정의된다는 것을 의미합니다."
+
+#: src/generics/methods.md:28
+msgid "It is possible to write `impl Point<u32> { .. }`. "
+msgstr "`impl Point<u32> { .. }`와 같이 작성하는 것도 가능합니다. "
+
+#: src/generics/methods.md:29
+msgid ""
+"`Point` is still generic and you can use `Point<f64>`, but methods in this "
+"block will only be available for `Point<u32>`."
+msgstr ""
+"`Point`는 여전히 제네릭이며 `Point<f64>`를 사용할 수도 있지만 이 블록의 메서"
+"드는 `Point<u32>`만 쓸 수 있습니다."
+
+#: src/generics/monomorphization.md:3
+msgid "Generic code is turned into non-generic code based on the call sites:"
+msgstr "제네릭 코드는 호출부에서 비 제네릭 코드로 전환됩니다:"
+
+#: src/generics/monomorphization.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let integer = Some(5);\n"
+"    let float = Some(5.0);\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let integer = Some(5);\n"
+"    let float = Some(5.0);\n"
+"}\n"
+"```"
+
+#: src/generics/monomorphization.md:12
+msgid "behaves as if you wrote"
+msgstr "위 코드는 아래와 같이 동작합니다"
+
+#: src/generics/monomorphization.md:14
+msgid ""
+"```rust,editable\n"
+"enum Option_i32 {\n"
+"    Some(i32),\n"
+"    None,\n"
+"}\n"
+"\n"
+"enum Option_f64 {\n"
+"    Some(f64),\n"
+"    None,\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let integer = Option_i32::Some(5);\n"
+"    let float = Option_f64::Some(5.0);\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"enum Option_i32 {\n"
+"    Some(i32),\n"
+"    None,\n"
+"}\n"
+"\n"
+"enum Option_f64 {\n"
+"    Some(f64),\n"
+"    None,\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let integer = Option_i32::Some(5);\n"
+"    let float = Option_f64::Some(5.0);\n"
+"}\n"
+"```"
+
+#: src/generics/monomorphization.md:31
+msgid ""
+"This is a zero-cost abstraction: you get exactly the same result as if you "
+"had hand-coded the data structures without the abstraction."
+msgstr ""
+"이것이 바로 비용이 들지 않는 (zero-cost) 추상화 입니다: 러스트의 제네릭은 추"
+"상화를 거치지 않고 직접 구체적인 타입을 써서 코딩한 것과 정확히 동일한 결과"
+"를 보여줍니다."
+
 #: src/traits.md:3
 msgid ""
 "Rust lets you abstract over types with traits. They're similar to interfaces:"
@@ -10131,120 +11616,230 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/traits/default-methods.md:32 src/traits.md:41
+#: src/traits/trait-objects.md:3
 msgid ""
-"Traits may specify pre-implemented (default) methods and methods that users "
-"are required to implement themselves. Methods with default implementations "
-"can rely on required methods."
+"Trait objects allow for values of different types, for instance in a "
+"collection:"
 msgstr ""
-"트레잇은 사전 구현된 (기본값) 메서드와 사용자가 직접 구현해야 하는 메서드를 "
-"지정할 수 있습니다. 기본 구현이 있는 메서드는 필수 메서드를 사용할 수 있습니"
-"다."
+"트레잇 객체는 타입이 다른 값(예를 들어 컬렉션에 속한 각 값)들을 가질 수 있습"
+"니다:"
 
-#: src/traits/default-methods.md:35
-msgid "Move method `not_equal` to a new trait `NotEqual`."
-msgstr "`not_equal` 메서드를 새로운 트레잇인 `NotEqual`로 이동합니다."
-
-#: src/traits/default-methods.md:37
-msgid "Make `NotEqual` a super trait for `Equal`."
-msgstr "`NotEqual`을 `Equal`의 슈퍼 트레잇으로 만듭니다."
-
-#: src/traits/default-methods.md:38
+#: src/traits/trait-objects.md:5
 msgid ""
-"```rust,editable,compile_fail\n"
-"trait NotEqual: Equals {\n"
-"    fn not_equal(&self, other: &Self) -> bool {\n"
-"        !self.equal(other)\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"trait NotEqual: Equals {\n"
-"    fn not_equal(&self, other: &Self) -> bool {\n"
-"        !self.equal(other)\n"
-"    }\n"
-"}\n"
-"```"
-
-#: src/traits/default-methods.md:46
-msgid "Provide a blanket implementation of `NotEqual` for `Equal`."
-msgstr "`Equal`에 `NotEqual`의 포괄적 구현을 제공합니다."
-
-#: src/traits/default-methods.md:47
-msgid ""
-"```rust,editable,compile_fail\n"
-"trait NotEqual {\n"
-"    fn not_equal(&self, other: &Self) -> bool;\n"
+"```rust,editable\n"
+"trait Pet {\n"
+"    fn name(&self) -> String;\n"
 "}\n"
 "\n"
-"impl<T> NotEqual for T where T: Equals {\n"
-"    fn not_equal(&self, other: &Self) -> bool {\n"
-"        !self.equal(other)\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"trait NotEqual {\n"
-"    fn not_equal(&self, other: &Self) -> bool;\n"
+"struct Dog {\n"
+"    name: String,\n"
 "}\n"
 "\n"
-"impl<T> NotEqual for T where T: Equals {\n"
-"    fn not_equal(&self, other: &Self) -> bool {\n"
-"        !self.equal(other)\n"
+"struct Cat;\n"
+"\n"
+"impl Pet for Dog {\n"
+"    fn name(&self) -> String {\n"
+"        self.name.clone()\n"
+"    }\n"
+"}\n"
+"\n"
+"impl Pet for Cat {\n"
+"    fn name(&self) -> String {\n"
+"        String::from(\"The cat\") // No name, cats won't respond to it "
+"anyway.\n"
+"    }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let pets: Vec<Box<dyn Pet>> = vec![\n"
+"        Box::new(Cat),\n"
+"        Box::new(Dog { name: String::from(\"Fido\") }),\n"
+"    ];\n"
+"    for pet in pets {\n"
+"        println!(\"Hello {}!\", pet.name());\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"trait Pet {\n"
+"    fn name(&self) -> String;\n"
+"}\n"
+"\n"
+"struct Dog {\n"
+"    name: String,\n"
+"}\n"
+"\n"
+"struct Cat;\n"
+"\n"
+"impl Pet for Dog {\n"
+"    fn name(&self) -> String {\n"
+"        self.name.clone()\n"
+"    }\n"
+"}\n"
+"\n"
+"impl Pet for Cat {\n"
+"    fn name(&self) -> String {\n"
+"        String::from(\"The cat\") // No name, cats won't respond to it "
+"anyway.\n"
+"    }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let pets: Vec<Box<dyn Pet>> = vec![\n"
+"        Box::new(Cat),\n"
+"        Box::new(Dog { name: String::from(\"Fido\") }),\n"
+"    ];\n"
+"    for pet in pets {\n"
+"        println!(\"Hello {}!\", pet.name());\n"
 "    }\n"
 "}\n"
 "```"
 
-#: src/traits/default-methods.md:58
-msgid ""
-"With the blanket implementation, you no longer need `NotEqual` as a super "
-"trait for `Equal`."
-msgstr ""
-"포괄적 구현을 사용하면 더 이상 `NotEqual`이 `Equal`의 슈퍼 트레잇으로 필요하"
-"지 않습니다."
+#: src/traits/trait-objects.md:40
+msgid "Memory layout after allocating `pets`:"
+msgstr "`pets`를 할당한 이후의 메모리 레이아웃:"
 
-#: src/traits.md:42
+#: src/traits/trait-objects.md:42
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
+":                           :     :                                             :\n"
+":    "
+"pets                   :     :                                             :\n"
+":   +-----------+-------+   :     :   +-----+-----"
+"+                             :\n"
+":   | ptr       |   o---+---+-----+-->| o o | o o "
+"|                             :\n"
+":   | len       |     2 |   :     :   +-|-|-+-|-|-"
+"+                             :\n"
+":   | capacity  |     2 |   :     :     | |   | |   +---------------"
+"+           :\n"
+":   +-----------+-------+   :     :     | |   | '-->| name: \"Fido\"  "
+"|           :\n"
+":                           :     :     | |   |     +---------------"
+"+           :\n"
+"`- - - - - - - - - - - - - -'     :     | |   "
+"|                                 :\n"
+"                                  :     | |   |     +----------------------"
+"+    :   \n"
+"                                  :     | |   '---->| \"<Dog as Pet>::name\" "
+"|    :\n"
+"                                  :     | |         +----------------------"
+"+    : \n"
+"                                  :     | "
+"|                                     : \n"
+"                                  :     | |   +-"
+"+                               :   \n"
+"                                  :     | '-->|"
+"\\|                               :     \n"
+"                                  :     |     +-"
+"+                               :    \n"
+"                                  :     "
+"|                                       : \n"
+"                                  :     |     +----------------------"
+"+          : \n"
+"                                  :     '---->| \"<Cat as Pet>::name\" "
+"|          : \n"
+"                                  :           +----------------------"
+"+          :\n"
+"                                  :                                             :\n"
+"                                  '- - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
+"\n"
+"```"
+msgstr ""
+"```bob\n"
+" 스택                             힙\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
+":                           :     :                                             :\n"
+":    "
+"pets                   :     :                                             :\n"
+":   +-----------+-------+   :     :   +-----+-----"
+"+                             :\n"
+":   | ptr       |   o---+---+-----+-->| o o | o o "
+"|                             :\n"
+":   | len       |     2 |   :     :   +-|-|-+-|-|-"
+"+                             :\n"
+":   | capacity  |     2 |   :     :     | |   | |   +---------------"
+"+           :\n"
+":   +-----------+-------+   :     :     | |   | '-->| name: \"Fido\"  "
+"|           :\n"
+":                           :     :     | |   |     +---------------"
+"+           :\n"
+"`- - - - - - - - - - - - - -'     :     | |   "
+"|                                 :\n"
+"                                  :     | |   |     +----------------------"
+"+    :   \n"
+"                                  :     | |   '---->| \"<Dog as Pet>::name\" "
+"|    :\n"
+"                                  :     | |         +----------------------"
+"+    : \n"
+"                                  :     | "
+"|                                     : \n"
+"                                  :     | |   +-"
+"+                               :   \n"
+"                                  :     | '-->|"
+"\\|                               :     \n"
+"                                  :     |     +-"
+"+                               :    \n"
+"                                  :     "
+"|                                       : \n"
+"                                  :     |     +----------------------"
+"+          : \n"
+"                                  :     '---->| \"<Cat as Pet>::name\" "
+"|          : \n"
+"                                  :           +----------------------"
+"+          :\n"
+"                                  :                                             :\n"
+"                                  '- - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
+"\n"
+"```"
+
+#: src/traits/trait-objects.md:72
 msgid ""
 "Types that implement a given trait may be of different sizes. This makes it "
-"impossible to have things like `Vec<Greet>` in the example above."
+"impossible to have things like `Vec<Pet>` in the example above."
 msgstr ""
 "여러 타입이 같은 트레잇을 구현하더라도 그 크기는 서로 다를 수 있습니다. 그래"
-"서 `Vec<Greeet>`같은 것은 불가능합니다. 왜냐하면 `Greet`트레잇을 구현하는 타"
-"입들 중 어떤 크기의 타입이 실제로 사용될 지, 컴파일 시에 알 방법이 없는 반"
-"면, `Vec<>`는 타입의 크기를 컴파일 시에 알고자 하기 때문입니다."
+"서 `Vec<Greeet>`같은 것은 불가능합니다."
 
-#: src/traits.md:43
+#: src/traits/trait-objects.md:73
 msgid ""
-"`dyn Greet` is a way to tell the compiler about a dynamically sized type "
-"that implements `Greet`."
-msgstr "`dyn Greet`는 `Greet`을 구현하는, 가변 크기의 타입을 의미합니다."
+"`dyn Pet` is a way to tell the compiler about a dynamically sized type that "
+"implements `Pet`."
+msgstr ""
+"`dyn Pet`이라고 하면이 타입의 크기는 동적이며 `Pet`을 구현하고 있다고 컴파일"
+"러에게 알려주는 것입니다."
 
-#: src/traits.md:44
+#: src/traits/trait-objects.md:74
 msgid ""
-"In the example, `pets` holds Fat Pointers to objects that implement `Greet`. "
-"The Fat Pointer consists of two components, a pointer to the actual object "
-"and a pointer to the virtual method table for the `Greet` implementation of "
+"In the example, `pets` holds _fat pointers_ to objects that implement `Pet`. "
+"The fat pointer consists of two components, a pointer to the actual object "
+"and a pointer to the virtual method table for the `Pet` implementation of "
 "that particular object."
 msgstr ""
-"예제에서 `pets`는 `Greet`을 구현하는 객체들의 Fat pointer를 담고 있습니다. "
-"Fat pointer는 실제 객체에 대한 포인터와 그 객체가 `Greet`을 구현하고 있는 가"
-"상 함수 테이블에 대한 포인터를 가집니다."
+"예제에서 `pets`는 `Pet`을 구현하는 객체들의 _Fat 포인터_를 담고 있습니다. "
+"Fat 포인터는 실제 객체에 대한 포인터와 그 객체가 `Pet`을 구현하고 있는 가상 "
+"함수 테이블에 대한 포인터를 가집니다."
 
-#: src/traits.md:45
+#: src/traits/trait-objects.md:75
 msgid "Compare these outputs in the above example:"
 msgstr "아래 코드의 결과와 비교해보세요:"
 
-#: src/traits.md:46
+#: src/traits/trait-objects.md:76
 msgid ""
 "```rust,ignore\n"
 "    println!(\"{} {}\", std::mem::size_of::<Dog>(), std::mem::size_of::"
 "<Cat>());\n"
 "    println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::"
 "<&Cat>());\n"
-"    println!(\"{}\", std::mem::size_of::<&dyn Greet>());\n"
-"    println!(\"{}\", std::mem::size_of::<Box<dyn Greet>>());\n"
+"    println!(\"{}\", std::mem::size_of::<&dyn Pet>());\n"
+"    println!(\"{}\", std::mem::size_of::<Box<dyn Pet>>());\n"
 "```"
 msgstr ""
 "```rust,ignore\n"
@@ -10252,17 +11847,25 @@ msgstr ""
 "<Cat>());\n"
 "    println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::"
 "<&Cat>());\n"
-"    println!(\"{}\", std::mem::size_of::<&dyn Greet>());\n"
-"    println!(\"{}\", std::mem::size_of::<Box<dyn Greet>>());\n"
+"    println!(\"{}\", std::mem::size_of::<&dyn Pet>());\n"
+"    println!(\"{}\", std::mem::size_of::<Box<dyn Pet>>());\n"
 "```"
 
 #: src/traits/deriving-traits.md:3
-msgid "You can let the compiler derive a number of traits:"
+msgid ""
+"Rust derive macros work by automatically generating code that implements the "
+"specified traits for a data structure."
+msgstr ""
+"러스트의 derive 매크로는 데이터 구조체가 특정 트레잇을 구현하는 코드를 자동으"
+"로 만들어 줍니다."
+
+#: src/traits/deriving-traits.md:5
+msgid "You can let the compiler derive a number of traits as follows:"
 msgstr ""
 "컴파일러가 여러가지 트레잇을 상속(derive)하도록 할 수 있습니다. 이 경우 컴파"
 "일러가 트레잇을 자동으로 구현합니다:"
 
-#: src/traits/deriving-traits.md:5
+#: src/traits/deriving-traits.md:7
 msgid ""
 "```rust,editable\n"
 "#[derive(Debug, Clone, PartialEq, Eq, Default)]\n"
@@ -10305,9 +11908,9 @@ msgstr ""
 msgid ""
 "```rust,editable\n"
 "trait Equals {\n"
-"    fn equal(&self, other: &Self) -> bool;\n"
-"    fn not_equal(&self, other: &Self) -> bool {\n"
-"        !self.equal(other)\n"
+"    fn equals(&self, other: &Self) -> bool;\n"
+"    fn not_equals(&self, other: &Self) -> bool {\n"
+"        !self.equals(other)\n"
 "    }\n"
 "}\n"
 "\n"
@@ -10315,7 +11918,7 @@ msgid ""
 "struct Centimeter(i16);\n"
 "\n"
 "impl Equals for Centimeter {\n"
-"    fn equal(&self, other: &Centimeter) -> bool {\n"
+"    fn equals(&self, other: &Centimeter) -> bool {\n"
 "        self.0 == other.0\n"
 "    }\n"
 "}\n"
@@ -10323,16 +11926,16 @@ msgid ""
 "fn main() {\n"
 "    let a = Centimeter(10);\n"
 "    let b = Centimeter(20);\n"
-"    println!(\"{a:?} equals {b:?}: {}\", a.equal(&b));\n"
-"    println!(\"{a:?} not_equals {b:?}: {}\", a.not_equal(&b));\n"
+"    println!(\"{a:?} equals {b:?}: {}\", a.equals(&b));\n"
+"    println!(\"{a:?} not_equals {b:?}: {}\", a.not_equals(&b));\n"
 "}\n"
 "```"
 msgstr ""
 "```rust,editable\n"
 "trait Equals {\n"
-"    fn equal(&self, other: &Self) -> bool;\n"
-"    fn not_equal(&self, other: &Self) -> bool {\n"
-"        !self.equal(other)\n"
+"    fn equals(&self, other: &Self) -> bool;\n"
+"    fn not_equals(&self, other: &Self) -> bool {\n"
+"        !self.equals(other)\n"
 "    }\n"
 "}\n"
 "\n"
@@ -10340,7 +11943,7 @@ msgstr ""
 "struct Centimeter(i16);\n"
 "\n"
 "impl Equals for Centimeter {\n"
-"    fn equal(&self, other: &Centimeter) -> bool {\n"
+"    fn equals(&self, other: &Centimeter) -> bool {\n"
 "        self.0 == other.0\n"
 "    }\n"
 "}\n"
@@ -10348,11 +11951,294 @@ msgstr ""
 "fn main() {\n"
 "    let a = Centimeter(10);\n"
 "    let b = Centimeter(20);\n"
-"    println!(\"{a:?} equals {b:?}: {}\", a.equal(&b));\n"
-"    println!(\"{a:?} not_equals {b:?}: {}\", a.not_equal(&b));\n"
+"    println!(\"{a:?} equals {b:?}: {}\", a.equals(&b));\n"
+"    println!(\"{a:?} not_equals {b:?}: {}\", a.not_equals(&b));\n"
 "}\n"
 "```"
 
+#: src/traits/default-methods.md:32
+msgid ""
+"Traits may specify pre-implemented (default) methods and methods that users "
+"are required to implement themselves. Methods with default implementations "
+"can rely on required methods."
+msgstr ""
+"트레잇은, 그 트레잇이 정의된 위치에서 직접 구현되는 디폴트 메서드와, 거기에서"
+"는 선언만 존재하고 그 트레잇을 구현하는 타입에서 구현해야 하는, 두 종류의 메"
+"서드를 가질 수 있습니다. 디폴트 메서드를 구현할 때에는, 두 종류의 메서드 모"
+"두 사용(호출)할 수 있습니다."
+
+#: src/traits/default-methods.md:35
+msgid "Move method `not_equals` to a new trait `NotEquals`."
+msgstr "`not_equal` 메서드를 새로운 트레잇인 `NotEqual`로 이동합니다."
+
+#: src/traits/default-methods.md:37
+msgid "Make `Equals` a super trait for `NotEquals`."
+msgstr "`NotEqual`을 `Equal`의 슈퍼 트레잇으로 만듭니다."
+
+#: src/traits/default-methods.md:38
+msgid ""
+"```rust,editable,compile_fail\n"
+"trait NotEquals: Equals {\n"
+"    fn not_equals(&self, other: &Self) -> bool {\n"
+"        !self.equals(other)\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"trait NotEquals: Equals {\n"
+"    fn not_equals(&self, other: &Self) -> bool {\n"
+"        !self.equals(other)\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/traits/default-methods.md:46
+msgid "Provide a blanket implementation of `NotEquals` for `Equals`."
+msgstr "`Equal`에 `NotEqual`의 포괄적 구현을 제공합니다."
+
+#: src/traits/default-methods.md:47
+msgid ""
+"```rust,editable,compile_fail\n"
+"trait NotEquals {\n"
+"    fn not_equals(&self, other: &Self) -> bool;\n"
+"}\n"
+"\n"
+"impl<T> NotEquals for T where T: Equals {\n"
+"    fn not_equals(&self, other: &Self) -> bool {\n"
+"        !self.equals(other)\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"trait NotEquals {\n"
+"    fn not_equals(&self, other: &Self) -> bool;\n"
+"}\n"
+"\n"
+"impl<T> NotEquals for T where T: Equals {\n"
+"    fn not_equals(&self, other: &Self) -> bool {\n"
+"        !self.equals(other)\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/traits/default-methods.md:58
+msgid ""
+"With the blanket implementation, you no longer need `Equals` as a super "
+"trait for `NotEqual`."
+msgstr ""
+"포괄적 구현을 사용하면 더 이상 `NotEqual`이 `Equal`의 슈퍼 트레잇으로 필요하"
+"지 않습니다."
+
+#: src/traits/trait-bounds.md:3
+msgid ""
+"When working with generics, you often want to require the types to implement "
+"some trait, so that you can call this trait's methods."
+msgstr ""
+"제네릭을 이용하다 보면 타입이 어떤 트레잇을 구현하고 있어야 하는 경우가 있습"
+"니다. 그래야 그 트레잇의 메서드를 호출할 수 있기 때문입니다."
+
+#: src/traits/trait-bounds.md:6
+msgid "You can do this with `T: Trait` or `impl Trait`:"
+msgstr "`T: Trait` 혹은 `impl Trait`를 사용하면 됩니다:"
+
+#: src/traits/trait-bounds.md:8
+msgid ""
+"```rust,editable\n"
+"fn duplicate<T: Clone>(a: T) -> (T, T) {\n"
+"    (a.clone(), a.clone())\n"
+"}\n"
+"\n"
+"// Syntactic sugar for:\n"
+"//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
+"fn add_42_millions(x: impl Into<i32>) -> i32 {\n"
+"    x.into() + 42_000_000\n"
+"}\n"
+"\n"
+"// struct NotClonable;\n"
+"\n"
+"fn main() {\n"
+"    let foo = String::from(\"foo\");\n"
+"    let pair = duplicate(foo);\n"
+"    println!(\"{pair:?}\");\n"
+"\n"
+"    let many = add_42_millions(42_i8);\n"
+"    println!(\"{many}\");\n"
+"    let many_more = add_42_millions(10_000_000);\n"
+"    println!(\"{many_more}\");\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"fn duplicate<T: Clone>(a: T) -> (T, T) {\n"
+"    (a.clone(), a.clone())\n"
+"}\n"
+"\n"
+"// 다음에 대한 문법 슈가:\n"
+"//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
+"fn add_42_millions(x: impl Into<i32>) -> i32 {\n"
+"    x.into() + 42_000_000\n"
+"}\n"
+"\n"
+"// struct NotClonable;\n"
+"\n"
+"fn main() {\n"
+"    let foo = String::from(\"foo\");\n"
+"    let pair = duplicate(foo);\n"
+"    println!(\"{pair:?}\");\n"
+"\n"
+"    let many = add_42_millions(42_i8);\n"
+"    println!(\"{many}\");\n"
+"    let many_more = add_42_millions(10_000_000);\n"
+"    println!(\"{many_more}\");\n"
+"}\n"
+"```"
+
+#: src/traits/trait-bounds.md:35
+msgid "Show a `where` clause, students will encounter it when reading code."
+msgstr ""
+"`where` 문법을 사용할 수도 있습니다. 수강생들도 코드를 읽다가 그 문법을 마주"
+"할 수 있습니다."
+
+#: src/traits/trait-bounds.md:37
+msgid ""
+"```rust,ignore\n"
+"fn duplicate<T>(a: T) -> (T, T)\n"
+"where\n"
+"    T: Clone,\n"
+"{\n"
+"    (a.clone(), a.clone())\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,ignore\n"
+"fn duplicate<T>(a: T) -> (T, T)\n"
+"where\n"
+"    T: Clone,\n"
+"{\n"
+"    (a.clone(), a.clone())\n"
+"}\n"
+"```"
+
+#: src/traits/trait-bounds.md:46
+msgid "It declutters the function signature if you have many parameters."
+msgstr ""
+"이를 이용하면 타입 파라메터가 많은 경우 함수 시그니처를 간결하게 정리하는 데 "
+"도움이 됩니다."
+
+#: src/traits/trait-bounds.md:47
+msgid "It has additional features making it more powerful."
+msgstr "좀 더 강력한 추가 기능도 제공합니다."
+
+#: src/traits/trait-bounds.md:48
+msgid ""
+"If someone asks, the extra feature is that the type on the left of \":\" can "
+"be arbitrary, like `Option<T>`."
+msgstr "`:` 왼쪽에 임의의 타입(예를 들어 `Option<T>`)을 사용할 수 있습니다."
+
+#: src/traits/impl-trait.md:1
+msgid "`impl Trait`"
+msgstr "트레잇 구현하기(`impl Trait`)"
+
+#: src/traits/impl-trait.md:3
+msgid ""
+"Similar to trait bounds, an `impl Trait` syntax can be used in function "
+"arguments and return values:"
+msgstr ""
+"트레잇 바운드와 유사하게 `impl Trait` 문법은 함수의 인자와 반환값에도 적용 가"
+"능합니다:"
+
+#: src/traits/impl-trait.md:6
+msgid ""
+"```rust,editable\n"
+"use std::fmt::Display;\n"
+"\n"
+"fn get_x(name: impl Display) -> impl Display {\n"
+"    format!(\"Hello {name}\")\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let x = get_x(\"foo\");\n"
+"    println!(\"{x}\");\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::fmt::Display;\n"
+"\n"
+"fn get_x(name: impl Display) -> impl Display {\n"
+"    format!(\"Hello {name}\")\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let x = get_x(\"foo\");\n"
+"    println!(\"{x}\");\n"
+"}\n"
+"```"
+
+#: src/traits/impl-trait.md:19
+msgid "`impl Trait` allows you to work with types which you cannot name."
+msgstr "`impl Trait`를 이용하면 이름이 없는 타입을 다룰 수 있습니다."
+
+#: src/traits/impl-trait.md:23
+msgid ""
+"The meaning of `impl Trait` is a bit different in the different positions."
+msgstr "`impl Trait`는 어디에 사용되었느냐에 따라 의미가 조금씩 다릅니다."
+
+#: src/traits/impl-trait.md:25
+msgid ""
+"For a parameter, `impl Trait` is like an anonymous generic parameter with a "
+"trait bound."
+msgstr ""
+"함수 인자의 타입으로 사용되었을 경우에는 `impl Trait`는 트레잇 경계가 있는 익"
+"명의 제네릭 타입을 의미합니다."
+
+#: src/traits/impl-trait.md:27
+msgid ""
+"For a return type, it means that the return type is some concrete type that "
+"implements the trait, without naming the type. This can be useful when you "
+"don't want to expose the concrete type in a public API."
+msgstr ""
+"리턴 타입으로 사용되었을 경우에는, 그 트레잇을 구현하는 구체적인 타입인데, 타"
+"입 이름을 프로그래머가 짓지 않았다는 것을 의미합니다. 이는 그 구체적인 타입 "
+"이름을 API로 공개하고 싶지 않은 경우에 유용합니다."
+
+#: src/traits/impl-trait.md:31
+msgid ""
+"Inference is hard in return position. A function returning `impl Foo` picks "
+"the concrete type it returns, without writing it out in the source. A "
+"function returning a generic type like `collect<B>() -> B` can return any "
+"type satisfying `B`, and the caller may need to choose one, such as with "
+"`let x: Vec<_> = foo.collect()` or with the turbofish, `foo.collect::"
+"<Vec<_>>()`."
+msgstr ""
+"함수가 리턴되는 곳에서의 타입 추론은 어렵습니다. 어떤 함수의 리턴 타입이 "
+"`impl Foo`로 선언되어 있을 경우, 그 함수가 실제로 리턴하는 타입은 소스 코드 "
+"상 어디에도 나타나 있지 않습니다. `collect<B<() -> B`와 같이 제너릭 타입을 리"
+"턴하는 함수는 `B`를 만족하는 어떤 타입도 리턴할 수 있습니다. 이 경우, 호출하"
+"는 측에서는 `let x: Vec<_> = foo.collect()`나 터보피시 문법을 써서 `foo."
+"collect::<Vec<_>>()`와 같이 리턴 타입을 명시적으로 써 주어야 할 수도 있습니"
+"다."
+
+#: src/traits/impl-trait.md:37
+msgid ""
+"This example is great, because it uses `impl Display` twice. It helps to "
+"explain that nothing here enforces that it is _the same_ `impl Display` "
+"type. If we used a single  `T: Display`, it would enforce the constraint "
+"that input `T` and return `T` type are the same type. It would not work for "
+"this particular function, as the type we expect as input is likely not what "
+"`format!` returns. If we wanted to do the same via `: Display` syntax, we'd "
+"need two independent generic parameters."
+msgstr ""
+"이 예시는 `impl Display`가 두번 사용 되었다는 점에서 훌륭합니다. 여기서 중요"
+"한 것은 이 두 `impl Display`가 실제로 같은 타입일 필요가 없다는 것입니다. 만"
+"약 `T: Display`로 트레잇 경계를 정하고 입력 파라메터와 리턴 값의 타입을 모두 "
+"`T`로 했다면, 이는 입력과 리턴값이 같은 타입임을 강제합니다. 이렇게 했다면 위"
+"의 예제는 동작하지 않았을 것입니다. 왜냐하면, 입력 값의 타입이 `format!`이 리"
+"턴하는 타입과 같지 않을 가능성이 높기 때문입니다. 만약 `: Display` 문법을 사"
+"용하고 싶다면 독립적인 제네릭 매개변수가 두 개가 필요합니다."
+
 #: src/traits/important-traits.md:3
 msgid ""
 "We will now look at some of the most common traits of the Rust standard "
@@ -10368,7 +12254,7 @@ msgid ""
 msgstr ""
 "[`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html)와 "
 "[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html) "
-"트레잇은 `for` 루프에서 사용됩니다."
+"트레잇은 `for` 반복문에서 사용됩니다,"
 
 #: src/traits/important-traits.md:6
 msgid ""
@@ -10378,7 +12264,7 @@ msgid ""
 msgstr ""
 "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html)과 [`Into`]"
 "(https://doc.rust-lang.org/std/convert/trait.Into.html) 트레잇은 값을 변환할 "
-"때 사용됩니다."
+"때 사용됩니다,"
 
 #: src/traits/important-traits.md:7
 msgid ""
@@ -10387,7 +12273,7 @@ msgid ""
 msgstr ""
 "[`Read`](https://doc.rust-lang.org/std/io/trait.Read.html)와 [`Write`]"
 "(https://doc.rust-lang.org/std/io/trait.Write.html) 트레잇은 I/O에 사용됩니"
-"다."
+"다,"
 
 #: src/traits/important-traits.md:8
 msgid ""
@@ -10479,26 +12365,16 @@ msgstr ""
 
 #: src/traits/iterator.md:32
 msgid ""
-"`IntoIterator` is the trait that makes for loops work. It is implemented by "
-"collection types such as `Vec<T>` and references to them such as `&Vec<T>` "
-"and `&[T]`. Ranges also implement it."
-msgstr ""
-"`IntoIterator`는 루프가 작동하도록 만드는 트레잇입니다. `Vec<T>`와 같은 컬렉"
-"션 타입과 그에 대한 참조 타입(`&Vec<T>`, `&[T]`)들 모두 이 트레잇을 구현합니"
-"다. Range 역시 이를 구현합니다."
-
-#: src/traits/iterator.md:34 src/traits/iterator.md:32
-msgid ""
 "The `Iterator` trait implements many common functional programming "
 "operations over collections  (e.g. `map`, `filter`, `reduce`, etc). This is "
 "the trait where you can find all the documentation about them. In Rust these "
 "functions should produce the code as efficient as equivalent imperative "
 "implementations."
 msgstr ""
-"`Iterator` 트레잇은 컬렉션에 대해 다양한 함수형 프로그래밍 연산 (`map`, "
-"`filter`, `reduce` 등)을 구현합니다. 이 연산들에 대한 자세한 설명은 "
-"`Iterator` 트레잇의 API 레퍼런스에서 찾을 수 있습니다. 러스트에서 이러한 함수"
-"형 연산들은 절차형으로 구현된 코드와 동일한 성능을 보여줍니다."
+"`Iterator` 트레잇은 컬렉션에 대한 여러 일반적인 함수 프로그래밍 작업(예: "
+"`map`, `filter`, `reduce` 등)을 구현합니다. 이는 관련 문서를 모두 찾을 수 있"
+"는 트레잇입니다. Rust에서는 이러한 함수가, 이와 동일한 일을 하는 명령형 구현"
+"만큼 효율적인 코드를 생성합니다."
 
 #: src/traits/iterator.md:37
 msgid ""
@@ -10741,88 +12617,6 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/traits/operators.md:1
-msgid "`Add`, `Mul`, ..."
-msgstr "`Add`, `Mul`, ..."
-
-#: src/traits/operators.md:3
-msgid ""
-"Operator overloading is implemented via traits in [`std::ops`](https://doc."
-"rust-lang.org/std/ops/index.html):"
-msgstr "연산자 오버로드는 `std::ops`에 있는 다양한 트레잇들을 통해 구현됩니다:"
-
-#: src/traits/operators.md:5
-msgid ""
-"```rust,editable\n"
-"#[derive(Debug, Copy, Clone)]\n"
-"struct Point { x: i32, y: i32 }\n"
-"\n"
-"impl std::ops::Add for Point {\n"
-"    type Output = Self;\n"
-"\n"
-"    fn add(self, other: Self) -> Self {\n"
-"        Self {x: self.x + other.x, y: self.y + other.y}\n"
-"    }\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    let p1 = Point { x: 10, y: 20 };\n"
-"    let p2 = Point { x: 100, y: 200 };\n"
-"    println!(\"{:?} + {:?} = {:?}\", p1, p2, p1 + p2);\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"#[derive(Debug, Copy, Clone)]\n"
-"struct Point { x: i32, y: i32 }\n"
-"\n"
-"impl std::ops::Add for Point {\n"
-"    type Output = Self;\n"
-"\n"
-"    fn add(self, other: Self) -> Self {\n"
-"        Self {x: self.x + other.x, y: self.y + other.y}\n"
-"    }\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    let p1 = Point { x: 10, y: 20 };\n"
-"    let p2 = Point { x: 100, y: 200 };\n"
-"    println!(\"{:?} + {:?} = {:?}\", p1, p2, p1 + p2);\n"
-"}\n"
-"```"
-
-#: src/traits/operators.md:26 src/traits/drop.md:34
-msgid "Discussion points:"
-msgstr "논의점:"
-
-#: src/traits/operators.md:28
-msgid ""
-"You could implement `Add` for `&Point`. In which situations is that useful? "
-msgstr ""
-"`&Point`가 `Add`를 구현하도록 할 수도 있습니다. 이게 어떤 경우에 유용할까요?"
-
-#: src/traits/operators.md:29
-msgid ""
-"Answer: `Add:add` consumes `self`. If type `T` for which you are overloading "
-"the operator is not `Copy`, you should consider overloading the operator for "
-"`&T` as well. This avoids unnecessary cloning on the call site."
-msgstr ""
-"답: `Add:add`는 `self`를 소모합니다. 만약 타입 `T`가 `Copy`트레잇을 구현하고 "
-"있지 않다면 `&T`에 대해서도 연산자 오버로딩을 고려해야 합니다. 이렇게 하면 호"
-"출부에서 불필요한 복사를 피할 수 있습니다."
-
-#: src/traits/operators.md:33
-msgid "Why is `Output` an associated type? Could it be made a type parameter?"
-msgstr "왜 `Output`이 연관된 타입인가요? 타입 파라메터로 만들 수 있을까요?"
-
-#: src/traits/operators.md:34
-msgid ""
-"Short answer: Type parameters are controlled by the caller, but associated "
-"types (like `Output`) are controlled by the implementor of a trait."
-msgstr ""
-"답: 타입 파라메터를 호출하는 쪽에서 결정합니다. 반면 연관된 타입(`Output`같"
-"은) 은 트레잇을 구현하는 쪽에서 제어 가능합니다."
-
 #: src/traits/drop.md:1
 msgid "The `Drop` Trait"
 msgstr "`Drop` 트레잇"
@@ -10891,6 +12685,10 @@ msgstr ""
 "}\n"
 "```"
 
+#: src/traits/drop.md:34 src/traits/operators.md:26
+msgid "Discussion points:"
+msgstr "논의점:"
+
 #: src/traits/drop.md:36
 msgid "Why doesn't `Drop::drop` take `self`?"
 msgstr "`Drop::drop`은 왜 `self`를 인자로 받지 않습니까?"
@@ -10901,7 +12699,7 @@ msgid ""
 "block, resulting in another call to `Drop::drop`, and a stack overflow!"
 msgstr ""
 "짧은 대답: 만약 그렇게 된다면 `std::mem::drop`이 블록의 끝에서 호출되고, 다"
-"시 `Drop::drop`을 호출하게되 스택 오버플로가 발생합니다."
+"시 `Drop::drop`을 호출하게 되어, 스택 오버플로가 발생합니다!"
 
 #: src/traits/drop.md:40
 msgid "Try replacing `drop(a)` with `a.drop()`."
@@ -10914,10 +12712,10 @@ msgstr "`Default` 트레잇"
 #: src/traits/default.md:3
 msgid ""
 "[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html) trait "
-"provides a default implementation of a trait."
+"produces a default value for a type."
 msgstr ""
 "[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html) 트레잇"
-"은 기본 구현을 제공합니다."
+"은 어떤 타입에 대한 기본값을 제공합니다."
 
 #: src/traits/default.md:5
 msgid ""
@@ -10939,12 +12737,12 @@ msgid ""
 "}\n"
 "\n"
 "fn main() {\n"
-"    let default_struct: Derived = Default::default();\n"
+"    let default_struct = Derived::default();\n"
 "    println!(\"{default_struct:#?}\");\n"
 "\n"
 "    let almost_default_struct = Derived {\n"
 "        y: \"Y is set!\".into(),\n"
-"        ..Default::default()\n"
+"        ..Derived::default()\n"
 "    };\n"
 "    println!(\"{almost_default_struct:#?}\");\n"
 "\n"
@@ -10972,12 +12770,12 @@ msgstr ""
 "}\n"
 "\n"
 "fn main() {\n"
-"    let default_struct: Derived = Default::default();\n"
+"    let default_struct = Derived::default();\n"
 "    println!(\"{default_struct:#?}\");\n"
 "\n"
 "    let almost_default_struct = Derived {\n"
 "        y: \"Y is set!\".into(),\n"
-"        ..Default::default()\n"
+"        ..Derived::default()\n"
 "    };\n"
 "    println!(\"{almost_default_struct:#?}\");\n"
 "\n"
@@ -10996,7 +12794,7 @@ msgstr ""
 
 #: src/traits/default.md:41
 msgid ""
-"Derived implementation will produce an instance where all fields are set to "
+"A derived implementation will produce a value where all fields are set to "
 "their default values."
 msgstr ""
 "컴파일러가 제공하는 자동 구현의 경우 모든 필드에 대해 기본 값을 설정한 새 인"
@@ -11004,7 +12802,9 @@ msgstr ""
 
 #: src/traits/default.md:42
 msgid "This means all types in the struct must implement `Default` too."
-msgstr "구조체의 각 필드 타입들이 모두 `Default`를 구현해야 함을 의미합니다."
+msgstr ""
+"이는 구조체의 각 필드 타입들이 모두 `Default` 트레잇을 구현해야 함을 의미합니"
+"다."
 
 #: src/traits/default.md:43
 msgid ""
@@ -11016,7 +12816,8 @@ msgstr ""
 
 #: src/traits/default.md:44
 msgid "The partial struct copy works nicely with default."
-msgstr "구조체 부분 복사를 할때 `default`를 편리하게 사용할 수 있습니다."
+msgstr ""
+"구조체의 일부분만 복사하고 싶을 때 `default`를 편리하게 사용할 수 있습니다."
 
 #: src/traits/default.md:45
 msgid ""
@@ -11026,327 +12827,110 @@ msgstr ""
 "러스트 표준 라이브러리는 `Default` 트레잇을 구현한 타입을 위한 편의 메서드를 "
 "제공하기도 합니다."
 
-#: src/generics.md:3
+#: src/traits/default.md:46
 msgid ""
-"Rust support generics, which lets you abstract an algorithm (such as "
-"sorting) over the types used in the algorithm."
+"the `..` syntax is called [struct update syntax](https://doc.rust-lang.org/"
+"book/ch05-01-defining-structs.html#creating-instances-from-other-instances-"
+"with-struct-update-syntax)"
 msgstr ""
-"러스트는 제네릭을 지원합니다. 이를 이용하면 알고리즘(정렬과 같은)을 추상화 하"
-"여 특정 타입에 의존하지 않도록 할 수 있습니다."
+"이 `..` 문법은 [구조체 업데이트 문법(struct update syntax)](https://doc.rust-"
+"lang.org/book/ch05-01-defining-structs.html#creating-instances-from-other-"
+"instances-with-struct-update-syntax)라고 합니다"
 
-#: src/generics/data-types.md:3
-msgid "You can use generics to abstract over the concrete field type:"
-msgstr "제네릭을 사용하여 필드의 타입을 추상화 할 수 있습니다:"
+#: src/traits/operators.md:1
+msgid "`Add`, `Mul`, ..."
+msgstr "`Add`, `Mul`, ..."
 
-#: src/generics/data-types.md:5
+#: src/traits/operators.md:3
+msgid ""
+"Operator overloading is implemented via traits in [`std::ops`](https://doc."
+"rust-lang.org/std/ops/index.html):"
+msgstr "연산자 오버로드는 `std::ops`에 있는 다양한 트레잇들을 통해 구현됩니다:"
+
+#: src/traits/operators.md:5
 msgid ""
 "```rust,editable\n"
-"#[derive(Debug)]\n"
-"struct Point<T> {\n"
-"    x: T,\n"
-"    y: T,\n"
-"}\n"
+"#[derive(Debug, Copy, Clone)]\n"
+"struct Point { x: i32, y: i32 }\n"
 "\n"
-"fn main() {\n"
-"    let integer = Point { x: 5, y: 10 };\n"
-"    let float = Point { x: 1.0, y: 4.0 };\n"
-"    println!(\"{integer:?} and {float:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"#[derive(Debug)]\n"
-"struct Point<T> {\n"
-"    x: T,\n"
-"    y: T,\n"
-"}\n"
+"impl std::ops::Add for Point {\n"
+"    type Output = Self;\n"
 "\n"
-"fn main() {\n"
-"    let integer = Point { x: 5, y: 10 };\n"
-"    let float = Point { x: 1.0, y: 4.0 };\n"
-"    println!(\"{integer:?} and {float:?}\");\n"
-"}\n"
-"```"
-
-#: src/generics/data-types.md:21
-msgid "Try declaring a new variable `let p = Point { x: 5, y: 10.0 };`."
-msgstr "새 변수 `let p = Point { x: 5, y: 10.0 };`를 선언해 보세요."
-
-#: src/generics/data-types.md:23
-msgid "Fix the code to allow points that have elements of different types."
-msgstr ""
-"`Point`가 서로 다른 타입의 값들으로 이루어져도 컴파일 되도록 코드를 수정해 보"
-"세요."
-
-#: src/generics/methods.md:3
-msgid "You can declare a generic type on your `impl` block:"
-msgstr "`impl` 블록에서도 제네릭 타입을 선언할 수 있습니다:"
-
-#: src/generics/methods.md:5
-msgid ""
-"```rust,editable\n"
-"#[derive(Debug)]\n"
-"struct Point<T>(T, T);\n"
-"\n"
-"impl<T> Point<T> {\n"
-"    fn x(&self) -> &T {\n"
-"        &self.0  // + 10\n"
+"    fn add(self, other: Self) -> Self {\n"
+"        Self {x: self.x + other.x, y: self.y + other.y}\n"
 "    }\n"
-"\n"
-"    // fn set_x(&mut self, x: T)\n"
 "}\n"
 "\n"
 "fn main() {\n"
-"    let p = Point(5, 10);\n"
-"    println!(\"p.x = {}\", p.x());\n"
+"    let p1 = Point { x: 10, y: 20 };\n"
+"    let p2 = Point { x: 100, y: 200 };\n"
+"    println!(\"{:?} + {:?} = {:?}\", p1, p2, p1 + p2);\n"
 "}\n"
 "```"
 msgstr ""
 "```rust,editable\n"
-"#[derive(Debug)]\n"
-"struct Point<T>(T, T);\n"
+"#[derive(Debug, Copy, Clone)]\n"
+"struct Point { x: i32, y: i32 }\n"
 "\n"
-"impl<T> Point<T> {\n"
-"    fn x(&self) -> &T {\n"
-"        &self.0  // + 10\n"
+"impl std::ops::Add for Point {\n"
+"    type Output = Self;\n"
+"\n"
+"    fn add(self, other: Self) -> Self {\n"
+"        Self {x: self.x + other.x, y: self.y + other.y}\n"
 "    }\n"
-"\n"
-"    // fn set_x(&mut self, x: T)\n"
 "}\n"
 "\n"
 "fn main() {\n"
-"    let p = Point(5, 10);\n"
-"    println!(\"p.x = {}\", p.x());\n"
+"    let p1 = Point { x: 10, y: 20 };\n"
+"    let p2 = Point { x: 100, y: 200 };\n"
+"    println!(\"{:?} + {:?} = {:?}\", p1, p2, p1 + p2);\n"
 "}\n"
 "```"
 
-#: src/generics/methods.md:25
+#: src/traits/operators.md:28
 msgid ""
-"_Q:_ Why `T` is specified twice in `impl<T> Point<T> {}`? Isn't that "
-"redundant?"
-msgstr "_질문:_ `impl<T> Point<T> {}`에서 `T`가 왜 두 번 사용됩니까?"
+"You could implement `Add` for `&Point`. In which situations is that useful? "
+msgstr ""
+"`&Point`가 `Add`를 구현하도록 할 수도 있습니다. 이게 어떤 경우에 유용할까요? "
 
-#: src/generics/methods.md:26
+#: src/traits/operators.md:29
 msgid ""
-"This is because it is a generic implementation section for generic type. "
-"They are independently generic."
+"Answer: `Add:add` consumes `self`. If type `T` for which you are overloading "
+"the operator is not `Copy`, you should consider overloading the operator for "
+"`&T` as well. This avoids unnecessary cloning on the call site."
 msgstr ""
-"제네릭 타입에 대한 제네릭 구현 이기 때문입니다. 이 두 제네릭은 서로 독립적입"
-"니다."
+"답: `Add:add`는 `self`를 소모합니다. 만약 타입 `T`가 `Copy`트레잇을 구현하고 "
+"있지 않다면 `&T`에 대해서도 연산자 오버로딩을 고려해야 합니다. 이렇게 하면 호"
+"출부에서 불필요한 복사를 피할 수 있습니다."
 
-#: src/generics/methods.md:27
-msgid "It means these methods are defined for any `T`."
-msgstr ""
-"이는 임의의 모든 `T`에 대해서 이 메소드들이 정의된다는 것을 의미합니다."
-
-#: src/generics/methods.md:28
-msgid "It is possible to write `impl Point<u32> { .. }`. "
-msgstr "`impl Point<u32> { .. }`와 같이 작성하는 것도 가능합니다."
-
-#: src/generics/methods.md:29
+#: src/traits/operators.md:33
 msgid ""
-"`Point` is still generic and you can use `Point<f64>`, but methods in this "
-"block will only be available for `Point<u32>`."
-msgstr ""
-"`Point`는 여전히 제네릭이며 `Point<f64>`를 사용할 수도 있지만 이 블록의 메서"
-"드는 `Point<u32>`만 쓸 수 있습니다."
+"Why is `Output` an associated type? Could it be made a type parameter of the "
+"method?"
+msgstr "왜 `Output`이 연관된 타입인가요? 타입 파라메터로 만들 수 있을까요?"
 
-#: src/generics/trait-bounds.md:3
+#: src/traits/operators.md:34
 msgid ""
-"When working with generics, you often want to require the types to implement "
-"some trait, so that you can call this trait's methods."
+"Short answer: Function type parameters are controlled by the caller, but "
+"associated types (like `Output`) are controlled by the implementor of a "
+"trait."
 msgstr ""
-"제네릭을 이용하다 보면 타입이 어떤 트레잇을 구현하고 있어야 하는 경우가 있습"
-"니다. 그래야 그 트레잇의 메서드를 호출할 수 있기 때문입니다."
+"답: 타입 파라메터를 호출하는 쪽에서 결정합니다. 반면 연관된 타입(`Output`같"
+"은) 은 트레잇을 구현하는 쪽에서 제어 가능합니다."
 
-#: src/generics/trait-bounds.md:6
-msgid "You can do this with `T: Trait` or `impl Trait`:"
-msgstr "`T: Trait` 혹은 `impl Trait`를 사용하면 됩니다:"
-
-#: src/traits/trait-bounds.md:8
+#: src/traits/operators.md:37
 msgid ""
-"```rust,editable\n"
-"fn duplicate<T: Clone>(a: T) -> (T, T) {\n"
-"    (a.clone(), a.clone())\n"
-"}\n"
-"\n"
-"// Syntactic sugar for:\n"
-"//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
-"fn add_42_millions(x: impl Into<i32>) -> i32 {\n"
-"    x.into() + 42_000_000\n"
-"}\n"
-"\n"
-"// struct NotClonable;\n"
-"\n"
-"fn main() {\n"
-"    let foo = String::from(\"foo\");\n"
-"    let pair = duplicate(foo);\n"
-"    println!(\"{pair:?}\");\n"
-"\n"
-"    let many = add_42_millions(42_i8);\n"
-"    println!(\"{many}\");\n"
-"    let many_more = add_42_millions(10_000_000);\n"
-"    println!(\"{many_more}\");\n"
-"}\n"
-"```"
+"You could implement `Add` for two different types, e.g. `impl Add<(i32, "
+"i32)> for Point` would add a tuple to a `Point`."
 msgstr ""
-"```rust,editable\n"
-"fn duplicate<T: Clone>(a: T) -> (T, T) {\n"
-"    (a.clone(), a.clone())\n"
-"}\n"
-"\n"
-"// 다음에 대한 문법 슈가:\n"
-"//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
-"fn add_42_millions(x: impl Into<i32>) -> i32 {\n"
-"    x.into() + 42_000_000\n"
-"}\n"
-"\n"
-"// struct NotClonable;\n"
-"\n"
-"fn main() {\n"
-"    let foo = String::from(\"foo\");\n"
-"    let pair = duplicate(foo);\n"
-"    println!(\"{pair:?}\");\n"
-"\n"
-"    let many = add_42_millions(42_i8);\n"
-"    println!(\"{many}\");\n"
-"    let many_more = add_42_millions(10_000_000);\n"
-"    println!(\"{many_more}\");\n"
-"}\n"
-"```"
+"`Add`를 이용해서 서로 다른 두 개의 타입을 더할 수도 있습니다. 예를 들어 "
+"`impl Add<(i32, i32)> for Point`는 튜플을 `Point`에 더할 수 있게 해 줍니다."
 
-#: src/generics/trait-bounds.md:35
-msgid "Show a `where` clause, students will encounter it when reading code."
-msgstr ""
-"`where` 문법을 사용할 수도 있습니다. 수강생들도 코드를 읽다가 그 문법을 마주"
-"할 수 있습니다."
+#: src/traits/closures.md:1
+msgid "Closures"
+msgstr "클로저(Closure)"
 
-#: src/generics/trait-bounds.md:37
-msgid ""
-"```rust,ignore\n"
-"fn duplicate<T>(a: T) -> (T, T)\n"
-"where\n"
-"    T: Clone,\n"
-"{\n"
-"    (a.clone(), a.clone())\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,ignore\n"
-"fn duplicate<T>(a: T) -> (T, T)\n"
-"where\n"
-"    T: Clone,\n"
-"{\n"
-"    (a.clone(), a.clone())\n"
-"}\n"
-"```"
-
-#: src/generics/trait-bounds.md:46
-msgid "It declutters the function signature if you have many parameters."
-msgstr ""
-"이를 이용하면 타입 파라메터가 많은 경우 함수 시그니처를 간결하게 정리하는 데 "
-"도움이 됩니다."
-
-#: src/generics/trait-bounds.md:47
-msgid "It has additional features making it more powerful."
-msgstr "좀 더 강력한 추가 기능도 제공합니다."
-
-#: src/generics/trait-bounds.md:48
-msgid ""
-"If someone asks, the extra feature is that the type on the left of \":\" can "
-"be arbitrary, like `Option<T>`."
-msgstr "`:` 왼쪽에 임의의 타입(예를 들어 `Option<T>`)을 사용할 수 있습니다."
-
-#: src/generics/impl-trait.md:1
-msgid "`impl Trait`"
-msgstr "트레잇 구현하기(`impl Trait`)"
-
-#: src/generics/impl-trait.md:3
-msgid ""
-"Similar to trait bounds, an `impl Trait` syntax can be used in function "
-"arguments and return values:"
-msgstr ""
-"트레잇 바운드와 유사하게 `impl Trait` 문법은 함수의 인자와 반환값에도 적용 가"
-"능합니다:"
-
-#: src/traits/impl-trait.md:6
-msgid ""
-"```rust,editable\n"
-"use std::fmt::Display;\n"
-"\n"
-"fn get_x(name: impl Display) -> impl Display {\n"
-"    format!(\"Hello {name}\")\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    let x = get_x(\"foo\");\n"
-"    println!(\"{x}\");\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"use std::fmt::Display;\n"
-"\n"
-"fn get_x(name: impl Display) -> impl Display {\n"
-"    format!(\"Hello {name}\")\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    let x = get_x(\"foo\");\n"
-"    println!(\"{x}\");\n"
-"}\n"
-"```"
-
-#: src/generics/impl-trait.md:19
-msgid "`impl Trait` cannot be used with the `::<>` turbo fish syntax."
-msgstr "`impl Trait`를 터보피쉬문법(`::<>`)과 함께 사용할 수는 없습니다."
-
-#: src/generics/impl-trait.md:20
-msgid "`impl Trait` allows you to work with types which you cannot name."
-msgstr "`impl Trait`를 이용하면 이름이 없는 타입을 다룰 수 있습니다."
-
-#: src/generics/impl-trait.md:24
-msgid ""
-"The meaning of `impl Trait` is a bit different in the different positions."
-msgstr "`impl Trait`는 어디에 사용되었느냐에 따라 의미가 조금씩 다릅니다."
-
-#: src/generics/impl-trait.md:26
-msgid ""
-"For a parameter, `impl Trait` is like an anonymous generic parameter with a "
-"trait bound."
-msgstr ""
-"함수 인자의 타입으로 사용되었을 경우에는 `impl Trait`는 트레잇 경계가 있는 익"
-"명의 제네릭 타입을 의미합니다."
-
-#: src/generics/impl-trait.md:27
-msgid ""
-"For a return type, it means that the return type is some concrete type that "
-"implements the trait, without naming the type. This can be useful when you "
-"don't want to expose the concrete type in a public API."
-msgstr ""
-"리턴 타입으로 사용되었을 경우에는, 그 트레잇을 구현하는 구체적인 타입인데, 타"
-"입 이름을 프로그래머가 짓지 않았다는 것을 의미합니다. 이는 그 구체적인 타입 "
-"이름을 API로 공개하고 싶지 않은 경우에 유용합니다."
-
-#: src/generics/impl-trait.md:31
-msgid ""
-"This example is great, because it uses `impl Display` twice. It helps to "
-"explain that nothing here enforces that it is _the same_ `impl Display` "
-"type. If we used a single  `T: Display`, it would enforce the constraint "
-"that input `T` and return `T` type are the same type. It would not work for "
-"this particular function, as the type we expect as input is likely not what "
-"`format!` returns. If we wanted to do the same via `: Display` syntax, we'd "
-"need two independent generic parameters."
-msgstr ""
-"이 예시는 `impl Display`가 두번 사용 되었다는 점에서 훌륭합니다. 여기서 중요"
-"한 것은 이 두 `impl Display`가 실제로 같은 타입일 필요가 없다는 것입니다. 만"
-"약 `T: Display`로 트레잇 경계를 정하고 입력 파라메터와 리턴 값의 타입을 모두 "
-"`T`로 했다면, 이는 입력과 리턴값이 같은 타입임을 강제합니다. 이렇게 했다면 위"
-"의 예제는 동작하지 않았을 것입니다. 왜냐하면, 입력 값의 타입이 `format!`이 리"
-"턴하는 타입과 같지 않을 가능성이 높기 때문입니다. 만약 `: Display` 문법을 사"
-"용하고 싶다면 독립적인 제네릭 매개변수가 두 개가 필요합니다."
-
-#: src/generics/closures.md:3
+#: src/traits/closures.md:3
 msgid ""
 "Closures or lambda expressions have types which cannot be named. However, "
 "they implement special [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn."
@@ -11368,10 +12952,19 @@ msgid ""
 "\n"
 "fn main() {\n"
 "    let add_3 = |x| x + 3;\n"
-"    let mul_5 = |x| x * 5;\n"
-"\n"
 "    println!(\"add_3: {}\", apply_with_log(add_3, 10));\n"
-"    println!(\"mul_5: {}\", apply_with_log(mul_5, 20));\n"
+"    println!(\"add_3: {}\", apply_with_log(add_3, 20));\n"
+"\n"
+"    let mut v = Vec::new();\n"
+"    let mut accumulate = |x: i32| {\n"
+"        v.push(x);\n"
+"        v.iter().sum::<i32>()\n"
+"    };\n"
+"    println!(\"accumulate: {}\", apply_with_log(&mut accumulate, 4));\n"
+"    println!(\"accumulate: {}\", apply_with_log(&mut accumulate, 5));\n"
+"\n"
+"    let multiply_sum = |x| x * v.into_iter().sum::<i32>();\n"
+"    println!(\"multiply_sum: {}\", apply_with_log(multiply_sum, 3));\n"
 "}\n"
 "```"
 msgstr ""
@@ -11383,36 +12976,47 @@ msgstr ""
 "\n"
 "fn main() {\n"
 "    let add_3 = |x| x + 3;\n"
-"    let mul_5 = |x| x * 5;\n"
-"\n"
 "    println!(\"add_3: {}\", apply_with_log(add_3, 10));\n"
-"    println!(\"mul_5: {}\", apply_with_log(mul_5, 20));\n"
+"    println!(\"add_3: {}\", apply_with_log(add_3, 20));\n"
+"\n"
+"    let mut v = Vec::new();\n"
+"    let mut accumulate = |x: i32| {\n"
+"        v.push(x);\n"
+"        v.iter().sum::<i32>()\n"
+"    };\n"
+"    println!(\"accumulate: {}\", apply_with_log(&mut accumulate, 4));\n"
+"    println!(\"accumulate: {}\", apply_with_log(&mut accumulate, 5));\n"
+"\n"
+"    let multiply_sum = |x| x * v.into_iter().sum::<i32>();\n"
+"    println!(\"multiply_sum: {}\", apply_with_log(multiply_sum, 3));\n"
 "}\n"
 "```"
 
-#: src/generics/closures.md:25
+#: src/traits/closures.md:34
 msgid ""
-"If you have an `FnOnce`, you may only call it once. It might consume "
-"captured values."
-msgstr "`FnOnce`는 한번만 호출되며 캡처된 값을 소모합니다."
-
-#: src/generics/closures.md:27
-msgid ""
-"An `FnMut` might mutate captured values, so you can call it multiple times "
-"but not concurrently."
+"An `Fn` (e.g. `add_3`) neither consumes nor mutates captured values, or "
+"perhaps captures nothing at all. It can be called multiple times "
+"concurrently."
 msgstr ""
-"`FnMut`는 캡처된 값을 변경할 수 있으므로 여러번 호출은 가능하지만 동시에 호"
-"출 할 수는 없습니다."
+"`Fn`(예를 들어 `add_3`)은 캡처된 값을 소모도 변경도 하지 않고, 혹은 어떤 것"
+"도 캡쳐하지 않았을 수도 있기 때문에 동시에 여러번 호출할 수 있습니다."
 
-#: src/generics/closures.md:29
+#: src/traits/closures.md:37
 msgid ""
-"An `Fn` neither consumes nor mutates captured values, or perhaps captures "
-"nothing at all, so it can be called multiple times concurrently."
+"An `FnMut` (e.g. `accumulate`) might mutate captured values. You can call it "
+"multiple times, but not concurrently."
 msgstr ""
-"`Fn`은 캡처된 값을 소모도 변경도 하지 않고, 혹은 어떤 것도 캡쳐하지 않았을 수"
-"도 있기 때문에 동시에 여러번 호출할 수 있습니다."
+"`FnMut`(예를 들어 `accumulate`)는 캡처된 값을 변경할 수 있으므로 여러 번 호출"
+"은 가능하지만 동시에 호출 할 수는 없습니다."
 
-#: src/generics/closures.md:32
+#: src/traits/closures.md:40
+msgid ""
+"If you have an `FnOnce` (e.g. `multiply_sum`), you may only call it once. It "
+"might consume captured values."
+msgstr ""
+"`FnOnce` (예를 들어 `multiply_sum`)는 한번만 호출되며 캡처된 값을 소모합니다."
+
+#: src/traits/closures.md:43
 msgid ""
 "`FnMut` is a subtype of `FnOnce`. `Fn` is a subtype of `FnMut` and `FnOnce`. "
 "I.e. you can use an `FnMut` wherever an `FnOnce` is called for, and you can "
@@ -11422,332 +13026,45 @@ msgstr ""
 "니다. 즉, `FnMut`는 `FnOnce`가 호출되는 곳이면 어디서나 사용 할 수 있고 `Fn`"
 "은 `FnMut`와 `FnOnce`가 호출되는 곳이면 어디든 사용할 수 있습니다."
 
-#: src/generics/closures.md:36
-msgid "`move` closures only implement `FnOnce`."
+#: src/traits/closures.md:47
+msgid ""
+"The compiler also infers `Copy` (e.g. for `add_3`) and `Clone` (e.g. "
+"`multiply_sum`), depending on what the closure captures."
 msgstr ""
-"클로저가 `move`와 함께 선언되었다면 그 클로저는 오직 `FnOnce`만 구현합니다."
+"컴파일러는 클로저가 무엇을 캡쳐하는지에 따라 `Copy`(예를 들어 `add_3`)과 "
+"`Clone`(예를 들어 `multiply_sum`)을 알아서 추론합니다."
 
-#: src/generics/monomorphization.md:3
-msgid "Generic code is turned into non-generic code based on the call sites:"
-msgstr "제네릭 코드는 호출부에서 비 제네릭 코드로 전환됩니다:"
+#: src/traits/closures.md:50
+msgid ""
+"By default, closures will capture by reference if they can. The `move` "
+"keyword makes them capture by value."
+msgstr ""
+"기본적으로 클로져는, 가능하다면, 참조를 사용하여 캡쳐를 합니다. `move` 키워드"
+"를 쓰면 값으로 캡쳐가 됩니다."
 
-#: src/generics/monomorphization.md:5
+#: src/traits/closures.md:52
 msgid ""
 "```rust,editable\n"
+"fn make_greeter(prefix: String) -> impl Fn(&str) {\n"
+"    return move |name| println!(\"{} {}\", prefix, name)\n"
+"}\n"
+"\n"
 "fn main() {\n"
-"    let integer = Some(5);\n"
-"    let float = Some(5.0);\n"
+"    let hi = make_greeter(\"Hi\".to_string());\n"
+"    hi(\"there\");\n"
 "}\n"
 "```"
 msgstr ""
 "```rust,editable\n"
-"fn main() {\n"
-"    let integer = Some(5);\n"
-"    let float = Some(5.0);\n"
-"}\n"
-"```"
-
-#: src/generics/monomorphization.md:12
-msgid "behaves as if you wrote"
-msgstr "위 코드는 아래와 같이 동작합니다"
-
-#: src/generics/monomorphization.md:14
-msgid ""
-"```rust,editable\n"
-"enum Option_i32 {\n"
-"    Some(i32),\n"
-"    None,\n"
-"}\n"
-"\n"
-"enum Option_f64 {\n"
-"    Some(f64),\n"
-"    None,\n"
+"fn make_greeter(prefix: String) -> impl Fn(&str) {\n"
+"    return move |name| println!(\"{} {}\", prefix, name)\n"
 "}\n"
 "\n"
 "fn main() {\n"
-"    let integer = Option_i32::Some(5);\n"
-"    let float = Option_f64::Some(5.0);\n"
+"    let hi = make_greeter(\"Hi\".to_string());\n"
+"    hi(\"there\");\n"
 "}\n"
 "```"
-msgstr ""
-"```rust,editable\n"
-"enum Option_i32 {\n"
-"    Some(i32),\n"
-"    None,\n"
-"}\n"
-"\n"
-"enum Option_f64 {\n"
-"    Some(f64),\n"
-"    None,\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    let integer = Option_i32::Some(5);\n"
-"    let float = Option_f64::Some(5.0);\n"
-"}\n"
-"```"
-
-#: src/generics/monomorphization.md:31
-msgid ""
-"This is a zero-cost abstraction: you get exactly the same result as if you "
-"had hand-coded the data structures without the abstraction."
-msgstr ""
-"이것이 바로 비용이 들지 않는 (zero-cost) 추상화 입니다: 러스트의 제네릭은 추"
-"상화를 거치지 않고 직접 구체적인 타입을 써서 코딩한 것과 정확히 동일한 결과"
-"를 보여줍니다."
-
-#: src/generics/trait-objects.md:3
-msgid "We've seen how a function can take arguments which implement a trait:"
-msgstr ""
-"함수가 특정 트레잇을 구현하는 인자를 입력으로 받도록 하는 방법에 대해 설명했"
-"었습니다:"
-
-#: src/traits/trait-objects.md:3
-msgid ""
-"Trait objects allow for values of different types, for instance in a "
-"collection:"
-msgstr ""
-"트레잇 객체는 타입이 다른 값(예를 들어 컬렉션에 속한 각 값)들을 가질 수 있습"
-"니다."
-
-#: src/traits/trait-objects.md:5
-msgid ""
-"```rust,editable\n"
-"trait Pet {\n"
-"    fn name(&self) -> String;\n"
-"}\n"
-"\n"
-"struct Dog {\n"
-"    name: String,\n"
-"}\n"
-"\n"
-"struct Cat;\n"
-"\n"
-"impl Pet for Dog {\n"
-"    fn name(&self) -> String {\n"
-"        self.name.clone()\n"
-"    }\n"
-"}\n"
-"\n"
-"impl Pet for Cat {\n"
-"    fn name(&self) -> String {\n"
-"        String::from(\"The cat\") // No name, cats won't respond to it "
-"anyway.\n"
-"    }\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    let pets: Vec<Box<dyn Pet>> = vec![\n"
-"        Box::new(Cat),\n"
-"        Box::new(Dog { name: String::from(\"Fido\") }),\n"
-"    ];\n"
-"    for pet in pets {\n"
-"        println!(\"Hello {}!\", pet.name());\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"trait Pet {\n"
-"    fn name(&self) -> String;\n"
-"}\n"
-"\n"
-"struct Dog {\n"
-"    name: String,\n"
-"}\n"
-"\n"
-"struct Cat;\n"
-"\n"
-"impl Pet for Dog {\n"
-"    fn name(&self) -> String {\n"
-"        self.name.clone()\n"
-"    }\n"
-"}\n"
-"\n"
-"impl Pet for Cat {\n"
-"    fn name(&self) -> String {\n"
-"        String::from(\"The cat\") // No name, cats won't respond to it "
-"anyway.\n"
-"    }\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    let pets: Vec<Box<dyn Pet>> = vec![\n"
-"        Box::new(Cat),\n"
-"        Box::new(Dog { name: String::from(\"Fido\") }),\n"
-"    ];\n"
-"    for pet in pets {\n"
-"        println!(\"Hello {}!\", pet.name());\n"
-"    }\n"
-"}\n"
-"```"
-
-#: src/generics/trait-objects.md:18
-msgid ""
-"However, how can we store a collection of mixed types which implement "
-"`Display`?"
-msgstr ""
-"그런데, 아래와 같이 `Display`를 구현하는 서로 다른 타입들의 콜렉션을 저장하"
-"고 싶다면 어떻게 해야 할까요?"
-
-#: src/generics/trait-objects.md:20
-msgid ""
-"```rust,editable,compile_fail\n"
-"fn main() {\n"
-"    let xs = vec![123, \"Hello\"];\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/generics/trait-objects.md:26
-msgid "For this, we need _trait objects_:"
-msgstr "이를 위해서는 \"트레잇 객체\"가 필요합니다:"
-
-#: src/generics/trait-objects.md:28
-msgid ""
-"```rust,editable\n"
-"use std::fmt::Display;\n"
-"\n"
-"fn main() {\n"
-"    let xs: Vec<Box<dyn Display>> = vec![Box::new(123), Box::"
-"new(\"Hello\")];\n"
-"    for x in xs {\n"
-"        println!(\"x: {x}\");\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/generics/trait-objects.md:39
-msgid "Memory layout after allocating `xs`:"
-msgstr "`xs`가 할당될때 메모리 레이아웃:"
-
-#: src/generics/trait-objects.md:41
-msgid ""
-"```bob\n"
-" Stack                             Heap\n"
-".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - "
-"- - -.\n"
-":                           :     :                                               :\n"
-":    "
-"xs                     :     :                                               :\n"
-":   +-----------+-------+   :     :   +-----+-----"
-"+                               :\n"
-":   | ptr       |   o---+---+-----+-->| o o | o o "
-"|                               :\n"
-":   | len       |     2 |   :     :   +-|-|-+-|-|-"
-"+                               :\n"
-":   | capacity  |     2 |   :     :     | |   | |   +----+----+----+----+----"
-"+    :\n"
-":   +-----------+-------+   :     :     | |   | '-->| H  | e  | l  | l  | o  "
-"|    :\n"
-":                           :     :     | |   |     +----+----+----+----+----"
-"+    :\n"
-"`- - - - - - - - - - - - - -'     :     | |   "
-"|                                   :\n"
-"                                  :     | |   |     "
-"+-------------------------+   :\n"
-"                                  :     | |   '---->| \"<str as Display>::"
-"fmt\" |   :\n"
-"                                  :     | |         "
-"+-------------------------+   :\n"
-"                                  :     | "
-"|                                       :\n"
-"                                  :     | |   +----+----+----+----"
-"+               :\n"
-"                                  :     | '-->| 7b | 00 | 00 | 00 "
-"|               :\n"
-"                                  :     |     +----+----+----+----"
-"+               :\n"
-"                                  :     "
-"|                                         :\n"
-"                                  :     |     +-------------------------"
-"+         :\n"
-"                                  :     '---->| \"<i32 as Display>::fmt\" "
-"|         :\n"
-"                                  :           +-------------------------"
-"+         :\n"
-"                                  :                                               :\n"
-"                                  :                                               :\n"
-"                                  '- - - - - - - - - - - - - - - - - - - - - "
-"- - -'\n"
-"```"
-msgstr ""
-"```bob\n"
-"  스택                               힙\n"
-".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - "
-"- - -.\n"
-":                           :     :                                               :\n"
-":    "
-"xs                     :     :                                               :\n"
-":   +-----------+-------+   :     :   +-----+-----"
-"+                               :\n"
-":   | ptr       |   o---+---+-----+-->| o o | o o "
-"|                               :\n"
-":   | len       |     2 |   :     :   +-|-|-+-|-|-"
-"+                               :\n"
-":   | capacity  |     2 |   :     :     | |   | |   +----+----+----+----+----"
-"+    :\n"
-":   +-----------+-------+   :     :     | |   | '-->| H  | e  | l  | l  | o  "
-"|    :\n"
-":                           :     :     | |   |     +----+----+----+----+----"
-"+    :\n"
-"`- - - - - - - - - - - - - -'     :     | |   "
-"|                                   :\n"
-"                                  :     | |   |     "
-"+-------------------------+   :\n"
-"                                  :     | |   '---->| \"<str as Display>::"
-"fmt\" |   :\n"
-"                                  :     | |         "
-"+-------------------------+   :\n"
-"                                  :     | "
-"|                                       :\n"
-"                                  :     | |   +----+----+----+----"
-"+               :\n"
-"                                  :     | '-->| 7b | 00 | 00 | 00 "
-"|               :\n"
-"                                  :     |     +----+----+----+----"
-"+               :\n"
-"                                  :     "
-"|                                         :\n"
-"                                  :     |     +-------------------------"
-"+         :\n"
-"                                  :     '---->| \"<i32 as Display>::fmt\" "
-"|         :\n"
-"                                  :           +-------------------------"
-"+         :\n"
-"                                  :                                               :\n"
-"                                  :                                               :\n"
-"                                  '- - - - - - - - - - - - - - - - - - - - - "
-"- - -'\n"
-"```"
-
-#: src/generics/trait-objects.md:69
-msgid ""
-"Similarly, you need a trait object if you want to return different types "
-"implementing a trait:"
-msgstr ""
-"마찬가지로, 같은 트레잇을 구현하는 서로 다른 타입의 값을 리턴할 때에도 트레"
-"잇 객체가 필요합니다:"
-
-#: src/generics/trait-objects.md:72
-msgid ""
-"```rust,editable\n"
-"fn numbers(n: i32) -> Box<dyn Iterator<Item=i32>> {\n"
-"    if n > 0 {\n"
-"        Box::new(0..n)\n"
-"    } else {\n"
-"        Box::new((n..0).rev())\n"
-"    }\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    println!(\"{:?}\", numbers(-5).collect::<Vec<_>>());\n"
-"    println!(\"{:?}\", numbers(5).collect::<Vec<_>>());\n"
-"}\n"
-"\n"
-"```"
-msgstr ""
 
 #: src/exercises/day-3/morning.md:1
 msgid "Day 3: Morning Exercises"
@@ -11863,6 +13180,13 @@ msgid ""
 "    fn add_widget(&mut self, widget: Box<dyn Widget>) {\n"
 "        self.widgets.push(widget);\n"
 "    }\n"
+"\n"
+"    fn inner_width(&self) -> usize {\n"
+"        std::cmp::max(\n"
+"            self.title.chars().count(),\n"
+"            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),\n"
+"        )\n"
+"    }\n"
 "}\n"
 "\n"
 "\n"
@@ -11908,12 +13232,124 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,should_panic\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_imports, unused_variables, dead_code)]\n"
+"\n"
+"pub trait Widget {\n"
+"    /// Natural width of `self`.\n"
+"    fn width(&self) -> usize;\n"
+"\n"
+"    /// Draw the widget into a buffer.\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);\n"
+"\n"
+"    /// Draw the widget on standard output.\n"
+"    fn draw(&self) {\n"
+"        let mut buffer = String::new();\n"
+"        self.draw_into(&mut buffer);\n"
+"        println!(\"{buffer}\");\n"
+"    }\n"
+"}\n"
+"\n"
+"pub struct Label {\n"
+"    label: String,\n"
+"}\n"
+"\n"
+"impl Label {\n"
+"    fn new(label: &str) -> Label {\n"
+"        Label {\n"
+"            label: label.to_owned(),\n"
+"        }\n"
+"    }\n"
+"}\n"
+"\n"
+"pub struct Button {\n"
+"    label: Label,\n"
+"    callback: Box<dyn FnMut()>,\n"
+"}\n"
+"\n"
+"impl Button {\n"
+"    fn new(label: &str, callback: Box<dyn FnMut()>) -> Button {\n"
+"        Button {\n"
+"            label: Label::new(label),\n"
+"            callback,\n"
+"        }\n"
+"    }\n"
+"}\n"
+"\n"
+"pub struct Window {\n"
+"    title: String,\n"
+"    widgets: Vec<Box<dyn Widget>>,\n"
+"}\n"
+"\n"
+"impl Window {\n"
+"    fn new(title: &str) -> Window {\n"
+"        Window {\n"
+"            title: title.to_owned(),\n"
+"            widgets: Vec::new(),\n"
+"        }\n"
+"    }\n"
+"\n"
+"    fn add_widget(&mut self, widget: Box<dyn Widget>) {\n"
+"        self.widgets.push(widget);\n"
+"    }\n"
+"\n"
+"    fn inner_width(&self) -> usize {\n"
+"        std::cmp::max(\n"
+"            self.title.chars().count(),\n"
+"            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),\n"
+"        )\n"
+"    }\n"
+"}\n"
+"\n"
+"\n"
+"impl Widget for Label {\n"
+"    fn width(&self) -> usize {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"}\n"
+"\n"
+"impl Widget for Button {\n"
+"    fn width(&self) -> usize {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"}\n"
+"\n"
+"impl Widget for Window {\n"
+"    fn width(&self) -> usize {\n"
+"        unimplemented!()\n"
+"    }\n"
+"\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let mut window = Window::new(\"Rust GUI Demo 1.23\");\n"
+"    window.add_widget(Box::new(Label::new(\"This is a small text GUI demo."
+"\")));\n"
+"    window.add_widget(Box::new(Button::new(\n"
+"        \"Click me!\",\n"
+"        Box::new(|| println!(\"You clicked the button!\")),\n"
+"    )));\n"
+"    window.draw();\n"
+"}\n"
+"```"
 
-#: src/exercises/day-3/simple-gui.md:123
+#: src/exercises/day-3/simple-gui.md:130
 msgid "The output of the above program can be something simple like this:"
 msgstr "위 프로그램의 출력은 아래와 같습니다:"
 
-#: src/exercises/day-3/simple-gui.md:125
+#: src/exercises/day-3/simple-gui.md:132
 msgid ""
 "```text\n"
 "========\n"
@@ -11925,8 +13361,17 @@ msgid ""
 "| Click me! |\n"
 "```"
 msgstr ""
+"```text\n"
+"========\n"
+"Rust GUI Demo 1.23\n"
+"========\n"
+"\n"
+"This is a small text GUI demo.\n"
+"\n"
+"| Click me! |\n"
+"```"
 
-#: src/exercises/day-3/simple-gui.md:135
+#: src/exercises/day-3/simple-gui.md:142
 msgid ""
 "If you want to draw aligned text, you can use the [fill/alignment](https://"
 "doc.rust-lang.org/std/fmt/index.html#fillalignment) formatting operators. In "
@@ -11937,7 +13382,7 @@ msgstr ""
 "fmt/index.html#fillalignment)를 참조하시기 바랍니다. 특수 문자(여기서는 "
 "`'/'`)로 패딩을 주는 방법과 정렬을 제어하는 방법을 확인하시기 바랍니다:"
 
-#: src/exercises/day-3/simple-gui.md:140
+#: src/exercises/day-3/simple-gui.md:147
 msgid ""
 "```rust,editable\n"
 "fn main() {\n"
@@ -11948,13 +13393,21 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let width = 10;\n"
+"    println!(\"left aligned:  |{:/<width$}|\", \"foo\");\n"
+"    println!(\"centered:      |{:/^width$}|\", \"foo\");\n"
+"    println!(\"right aligned: |{:/>width$}|\", \"foo\");\n"
+"}\n"
+"```"
 
-#: src/exercises/day-3/simple-gui.md:149
+#: src/exercises/day-3/simple-gui.md:156
 msgid ""
 "Using such alignment tricks, you can for example produce output like this:"
 msgstr "위의 정렬 트릭을 사용하여 다음과 같은 출력을 생성할 수 있습니다:"
 
-#: src/exercises/day-3/simple-gui.md:151
+#: src/exercises/day-3/simple-gui.md:158
 msgid ""
 "```text\n"
 "+--------------------------------+\n"
@@ -11967,6 +13420,16 @@ msgid ""
 "+--------------------------------+\n"
 "```"
 msgstr ""
+"```text\n"
+"+--------------------------------+\n"
+"|       Rust GUI Demo 1.23       |\n"
+"+================================+\n"
+"| This is a small text GUI demo. |\n"
+"| +-----------+                  |\n"
+"| | Click me! |                  |\n"
+"| +-----------+                  |\n"
+"+--------------------------------+\n"
+"```"
 
 #: src/error-handling.md:3
 msgid "Error handling in Rust is done using explicit control flow:"
@@ -11974,7 +13437,7 @@ msgstr "러스트에서 오류는 명시적인 흐름을 따라 처리가 됩니
 
 #: src/error-handling.md:5
 msgid "Functions that can have errors list this in their return type,"
-msgstr "오류를 발생할 수 있는 함수는 반환 타입에 이를 명시해야 합니다."
+msgstr "오류를 발생할 수 있는 함수는 반환 타입에 이를 명시해야 합니다,"
 
 #: src/error-handling.md:6
 msgid "There are no exceptions."
@@ -12027,54 +13490,41 @@ msgstr ""
 "기본적으로, 패닉이 발생하면 스택 되감기를 합니다. 스택 되감기는 다음과 같이 "
 "캐치가 가능합니다:"
 
-#: src/error-handling/panic-unwind.md:5
-msgid ""
-"```rust\n"
-"use std::panic;\n"
-"\n"
-"let result = panic::catch_unwind(|| {\n"
-"    println!(\"hello!\");\n"
-"});\n"
-"assert!(result.is_ok());\n"
-"\n"
-"let result = panic::catch_unwind(|| {\n"
-"    panic!(\"oh no!\");\n"
-"});\n"
-"assert!(result.is_err());\n"
-"```"
-msgstr ""
-
 #: src/error-handling/panic-unwind.md:5
 msgid ""
 "```rust,editable\n"
 "use std::panic;\n"
 "\n"
-"let result = panic::catch_unwind(|| {\n"
-"    println!(\"hello!\");\n"
-"});\n"
-"assert!(result.is_ok());\n"
-"\n"
-"let result = panic::catch_unwind(|| {\n"
-"    panic!(\"oh no!\");\n"
-"});\n"
-"assert!(result.is_err());\n"
+"fn main() {\n"
+"    let result = panic::catch_unwind(|| {\n"
+"        println!(\"hello!\");\n"
+"    });\n"
+"    assert!(result.is_ok());\n"
+"    \n"
+"    let result = panic::catch_unwind(|| {\n"
+"        panic!(\"oh no!\");\n"
+"    });\n"
+"    assert!(result.is_err());\n"
+"}\n"
 "```"
 msgstr ""
 "```rust,editable\n"
 "use std::panic;\n"
 "\n"
-"let result = panic::catch_unwind(|| {\n"
-"    println!(\"hello!\");\n"
-"});\n"
-"assert!(result.is_ok());\n"
-"\n"
-"let result = panic::catch_unwind(|| {\n"
-"    panic!(\"oh no!\");\n"
-"});\n"
-"assert!(result.is_err());\n"
+"fn main() {\n"
+"    let result = panic::catch_unwind(|| {\n"
+"        println!(\"hello!\");\n"
+"    });\n"
+"    assert!(result.is_ok());\n"
+"    \n"
+"    let result = panic::catch_unwind(|| {\n"
+"        panic!(\"oh no!\");\n"
+"    });\n"
+"    assert!(result.is_err());\n"
+"}\n"
 "```"
 
-#: src/error-handling/panic-unwind.md:19
+#: src/error-handling/panic-unwind.md:21
 msgid ""
 "This can be useful in servers which should keep running even if a single "
 "request crashes."
@@ -12082,7 +13532,7 @@ msgstr ""
 "이것은 단일 요청이 크래시 되더라도 프로그램이 계속 실행되야 하는 서버에 유용"
 "합니다."
 
-#: src/error-handling/panic-unwind.md:21
+#: src/error-handling/panic-unwind.md:23
 msgid "This does not work if `panic = 'abort'` is set in your `Cargo.toml`."
 msgstr ""
 "만약 `Cargo.toml`설정파일에 `panic = abort`을 설정했다면 크래시를 캐치할 수 "
@@ -12100,36 +13550,14 @@ msgstr ""
 "여러분은 이미 `Result` 열거형을 몇 번 봤습니다. 이 타입은 프로그램의 정상적"
 "인 수행 중에 발생할 수 있는 오류값들을 나타내기 위해 사용됩니다:"
 
-#: src/error-handling/result.md:6
-msgid ""
-"```rust\n"
-"use std::fs::File;\n"
-"use std::io::Read;\n"
-"\n"
-"fn main() {\n"
-"    let file = File::open(\"diary.txt\");\n"
-"    match file {\n"
-"        Ok(mut file) => {\n"
-"            let mut contents = String::new();\n"
-"            file.read_to_string(&mut contents);\n"
-"            println!(\"Dear diary: {contents}\");\n"
-"        },\n"
-"        Err(err) => {\n"
-"            println!(\"The diary could not be opened: {err}\");\n"
-"        }\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-
 #: src/error-handling/result.md:6
 msgid ""
 "```rust,editable\n"
-"use std::fs::File;\n"
+"use std::fs;\n"
 "use std::io::Read;\n"
 "\n"
 "fn main() {\n"
-"    let file = File::open(\"diary.txt\");\n"
+"    let file = fs::File::open(\"diary.txt\");\n"
 "    match file {\n"
 "        Ok(mut file) => {\n"
 "            let mut contents = String::new();\n"
@@ -12144,11 +13572,11 @@ msgid ""
 "```"
 msgstr ""
 "```rust,editable\n"
-"use std::fs::File;\n"
+"use std::fs;\n"
 "use std::io::Read;\n"
 "\n"
 "fn main() {\n"
-"    let file = File::open(\"diary.txt\");\n"
+"    let file = fs::File::open(\"diary.txt\");\n"
 "    match file {\n"
 "        Ok(mut file) => {\n"
 "            let mut contents = String::new();\n"
@@ -12182,7 +13610,7 @@ msgid ""
 "that help functional-style programming. "
 msgstr ""
 "수업중엔 아니지만 `Result`의 API 레퍼런스를 읽는 것을 권장합니다. 함수형 프로"
-"그래밍 스타일에 도움이 되는 편리한 메서드와 함수를 많이 배울 수 있습니다."
+"그래밍 스타일에 도움이 되는 편리한 메서드와 함수를 많이 배울 수 있습니다. "
 
 #: src/error-handling/try-operator.md:1
 msgid "Propagating Errors with `?`"
@@ -12214,7 +13642,7 @@ msgstr ""
 
 #: src/error-handling/try-operator.md:13
 msgid "into the much simpler"
-msgstr "이렇게 짧게 쓸 수 있습니다."
+msgstr "이렇게 짧게 쓸 수 있습니다"
 
 #: src/error-handling/try-operator.md:15
 msgid ""
@@ -12227,28 +13655,26 @@ msgstr ""
 "```"
 
 #: src/error-handling/try-operator.md:19
-msgid "We can use this to simplify our error handing code:"
+msgid "We can use this to simplify our error handling code:"
 msgstr "이제 우리 예제에 적용해 보겠습니다:"
 
 #: src/error-handling/try-operator.md:21
 msgid ""
 "```rust,editable\n"
-"use std::fs;\n"
-"use std::io::{self, Read};\n"
+"use std::{fs, io};\n"
+"use std::io::Read;\n"
 "\n"
 "fn read_username(path: &str) -> Result<String, io::Error> {\n"
 "    let username_file_result = fs::File::open(path);\n"
-"\n"
 "    let mut username_file = match username_file_result {\n"
 "        Ok(file) => file,\n"
-"        Err(e) => return Err(e),\n"
+"        Err(err) => return Err(err),\n"
 "    };\n"
 "\n"
 "    let mut username = String::new();\n"
-"\n"
 "    match username_file.read_to_string(&mut username) {\n"
 "        Ok(_) => Ok(username),\n"
-"        Err(e) => Err(e),\n"
+"        Err(err) => Err(err),\n"
 "    }\n"
 "}\n"
 "\n"
@@ -12259,13 +13685,37 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"use std::{fs, io};\n"
+"use std::io::Read;\n"
+"\n"
+"fn read_username(path: &str) -> Result<String, io::Error> {\n"
+"    let username_file_result = fs::File::open(path);\n"
+"    let mut username_file = match username_file_result {\n"
+"        Ok(file) => file,\n"
+"        Err(err) => return Err(err),\n"
+"    };\n"
+"\n"
+"    let mut username = String::new();\n"
+"    match username_file.read_to_string(&mut username) {\n"
+"        Ok(_) => Ok(username),\n"
+"        Err(err) => Err(err),\n"
+"    }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    //fs::write(\"config.dat\", \"alice\").unwrap();\n"
+"    let username = read_username(\"config.dat\");\n"
+"    println!(\"username or error: {username:?}\");\n"
+"}\n"
+"```"
 
-#: src/error-handling/try-operator.md:52
+#: src/error-handling/try-operator.md:50
 #: src/error-handling/converting-error-types-example.md:52
 msgid "The `username` variable can be either `Ok(string)` or `Err(error)`."
 msgstr "`username` 변수는 `Ok(string)`이거나 `Err(error)`일 수 있습니다."
 
-#: src/error-handling/try-operator.md:53
+#: src/error-handling/try-operator.md:51
 #: src/error-handling/converting-error-types-example.md:53
 msgid ""
 "Use the `fs::write` call to test out the different scenarios: no file, empty "
@@ -12274,6 +13724,33 @@ msgstr ""
 "`fs::write` 메서드를 사용하여 파일이 없거나, 비었거나, 중복되는 경우 등을 테"
 "스트해 봅니다."
 
+#: src/error-handling/try-operator.md:52
+msgid ""
+"The return type of the function has to be compatible with the nested "
+"functions it calls. For instance, a function returning a `Result<T, Err>` "
+"can only apply the `?` operator on a function returning a  `Result<AnyT, "
+"Err>`. It cannot apply the `?` operator on a function returning an "
+"`Option<AnyT>` or `Result<T, OtherErr>` unless `OtherErr` implements "
+"`From<Err>`. Reciprocally, a function returning an `Option<T>` can only "
+"apply the `?` operator  on a function returning an `Option<AnyT>`."
+msgstr ""
+"함수의 리턴 타입은 네스팅 되어 호출되는 함수의 리턴 타입과 호환되어야 합니"
+"다. 예를 들어 `Result<T, Err>`를 리턴하는 함수는 `Result<AnyT, Err>`를 리턴하"
+"는 함수를 호출할 때에만`?`를 사용할 수 있습니다. `Option<AnyT>`나 `Result<T, "
+"OtherErr>` (`OtherError`가 `From<Err>`를 구현하지 않는 다고 가정할 때)와 같"
+"은 타입을 리턴하는 함수를 호출할 때에는 `?`를 사용할 수 없습니다. 동일한 이유"
+"로, `Option<T>`를 리턴하는 함수는 `Option<AnyT>`를 리턴하는 함수를 호출할 때"
+"에만 `?`를 사용할 수 있습니다."
+
+#: src/error-handling/try-operator.md:57
+msgid ""
+"You can convert incompatible types into one another with the different "
+"`Option` and `Result` methods  such as `Option::ok_or`, `Result::ok`, "
+"`Result::err`."
+msgstr ""
+"`Option`과 `Result`간의 변환을 위해 `Option::ok_or`, `Result::ok`, `Result::"
+"err`와 같은 함수들을 사용할 수 있습니다."
+
 #: src/error-handling/converting-error-types.md:3
 msgid ""
 "The effective expansion of `?` is a little more complicated than previously "
@@ -12318,55 +13795,6 @@ msgstr ""
 "`From::from`을 통해 원래의 에러 타입을 이 함수가 반환하는 에러 타입으로 변환"
 "하고 있습니다:"
 
-#: src/error-handling/converting-error-types-example.md:3
-msgid ""
-"```rust,editable\n"
-"use std::error::Error;\n"
-"use std::fmt::{self, Display, Formatter};\n"
-"use std::fs::{self, File};\n"
-"use std::io::{self, Read};\n"
-"\n"
-"#[derive(Debug)]\n"
-"enum ReadUsernameError {\n"
-"    IoError(io::Error),\n"
-"    EmptyUsername(String),\n"
-"}\n"
-"\n"
-"impl Error for ReadUsernameError {}\n"
-"\n"
-"impl Display for ReadUsernameError {\n"
-"    fn fmt(&self, f: &mut Formatter) -> fmt::Result {\n"
-"        match self {\n"
-"            Self::IoError(e) => write!(f, \"IO error: {}\", e),\n"
-"            Self::EmptyUsername(filename) => write!(f, \"Found no username "
-"in {}\", filename),\n"
-"        }\n"
-"    }\n"
-"}\n"
-"\n"
-"impl From<io::Error> for ReadUsernameError {\n"
-"    fn from(err: io::Error) -> ReadUsernameError {\n"
-"        ReadUsernameError::IoError(err)\n"
-"    }\n"
-"}\n"
-"\n"
-"fn read_username(path: &str) -> Result<String, ReadUsernameError> {\n"
-"    let mut username = String::with_capacity(100);\n"
-"    File::open(path)?.read_to_string(&mut username)?;\n"
-"    if username.is_empty() {\n"
-"        return Err(ReadUsernameError::EmptyUsername(String::from(path)));\n"
-"    }\n"
-"    Ok(username)\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    //fs::write(\"config.dat\", \"\").unwrap();\n"
-"    let username = read_username(\"config.dat\");\n"
-"    println!(\"username or error: {username:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-
 #: src/error-handling/converting-error-types-example.md:3
 msgid ""
 "```rust,editable\n"
@@ -12463,17 +13891,27 @@ msgstr ""
 
 #: src/error-handling/converting-error-types-example.md:55
 msgid ""
-"It is good practice for all error types to implement `std::error::Error`, "
-"which requires `Debug` and `Display`. It's generally helpful for them to "
-"implement `Clone` and `Eq` too where possible, to make life easier for tests "
-"and consumers of your library. In this case we can't easily do so, because "
-"`io::Error` doesn't implement them."
+"It is good practice for all error types that don't need to be `no_std` to "
+"implement `std::error::Error`, which requires `Debug` and `Display`. The "
+"`Error` crate for `core` is only available in [nightly](https://github.com/"
+"rust-lang/rust/issues/103765), so not fully `no_std` compatible yet."
 msgstr ""
-"에러 타입이 `std::error::Error`를 구현하도록 하는 것은 좋은 습관입니다. 그러"
-"면 `Debug`와 `Display` 트레잇 또한 구현을 해야 합니다. 가능하다면 `Clone`과 "
-"`Eq` 트레잇도 구현하도록 하세요. 여러분의 라이브러리가 테스트 하기 쉬워지고, "
-"사용하기 좋아질 겁니다. 다만, 이 예제에서는 그렇게 하기 힘듭니다. 왜냐하면 "
-"`io::Error`는 이 트레잇들을 구현하고 있지 않기 때문입니다."
+"모든 에러 타입 (`no_std`이어야 하는 에러 타입을 제외하고)에 대해 `std::"
+"error::Error`를 구현하는 것은 좋은 습관입니다. `std::error::Error`를 구현한다"
+"는 것은 `Debug`와 `Display`도 구현한다는 것입니다. `core`를 위한 `Error`크레"
+"이크는 [나이틀리](https://github.com/rust-lang/rust/issues/103765)에만 제공"
+"이 됩니다. 그래서 아직 `no_std`환경에서 사용할 수는 없습니다."
+
+#: src/error-handling/converting-error-types-example.md:57
+msgid ""
+"It's generally helpful for them to implement `Clone` and `Eq` too where "
+"possible, to make life easier for tests and consumers of your library. In "
+"this case we can't easily do so, because `io::Error` doesn't implement them."
+msgstr ""
+"가능하다면 `Clone`과 `Eq` 트레잇도 구현하도록 하세요. 여러분의 라이브러리가 "
+"테스트 하기 쉬워지고, 사용하기 좋아질 겁니다. 다만, 이 예제에서는 그렇게 하"
+"기 힘듭니다. 왜냐하면 `io::Error`는 이 트레잇들을 구현하고 있지 않기 때문입니"
+"다."
 
 #: src/error-handling/deriving-error-enums.md:3
 msgid ""
@@ -12499,7 +13937,7 @@ msgid ""
 "}\n"
 "\n"
 "fn read_username(path: &str) -> Result<String, ReadUsernameError> {\n"
-"    let mut username = String::with_capacity(100);\n"
+"    let mut username = String::new();\n"
 "    fs::File::open(path)?.read_to_string(&mut username)?;\n"
 "    if username.is_empty() {\n"
 "        return Err(ReadUsernameError::EmptyUsername(String::from(path)));\n"
@@ -12530,7 +13968,7 @@ msgstr ""
 "}\n"
 "\n"
 "fn read_username(path: &str) -> Result<String, ReadUsernameError> {\n"
-"    let mut username = String::with_capacity(100);\n"
+"    let mut username = String::new();\n"
 "    fs::File::open(path)?.read_to_string(&mut username)?;\n"
 "    if username.is_empty() {\n"
 "        return Err(ReadUsernameError::EmptyUsername(String::from(path)));\n"
@@ -12577,7 +14015,7 @@ msgstr ""
 #: src/error-handling/dynamic-errors.md:6
 msgid ""
 "```rust,editable,compile_fail\n"
-"use std::fs::{self, File};\n"
+"use std::fs;\n"
 "use std::io::Read;\n"
 "use thiserror::Error;\n"
 "use std::error::Error;\n"
@@ -12587,8 +14025,8 @@ msgid ""
 "struct EmptyUsernameError(String);\n"
 "\n"
 "fn read_username(path: &str) -> Result<String, Box<dyn Error>> {\n"
-"    let mut username = String::with_capacity(100);\n"
-"    File::open(path)?.read_to_string(&mut username)?;\n"
+"    let mut username = String::new();\n"
+"    fs::File::open(path)?.read_to_string(&mut username)?;\n"
 "    if username.is_empty() {\n"
 "        return Err(EmptyUsernameError(String::from(path)).into());\n"
 "    }\n"
@@ -12605,7 +14043,7 @@ msgid ""
 "```"
 msgstr ""
 "```rust,editable,compile_fail\n"
-"use std::fs::{self, File};\n"
+"use std::fs;\n"
 "use std::io::Read;\n"
 "use thiserror::Error;\n"
 "use std::error::Error;\n"
@@ -12615,8 +14053,8 @@ msgstr ""
 "struct EmptyUsernameError(String);\n"
 "\n"
 "fn read_username(path: &str) -> Result<String, Box<dyn Error>> {\n"
-"    let mut username = String::with_capacity(100);\n"
-"    File::open(path)?.read_to_string(&mut username)?;\n"
+"    let mut username = String::new();\n"
+"    fs::File::open(path)?.read_to_string(&mut username)?;\n"
 "    if username.is_empty() {\n"
 "        return Err(EmptyUsernameError(String::from(path)).into());\n"
 "    }\n"
@@ -12760,7 +14198,7 @@ msgstr "단위 테스트는 `#[test]` 로 표시합니다:"
 
 #: src/testing/unit-tests.md:5
 msgid ""
-"```rust,ignore\n"
+"```rust,editable,ignore\n"
 "fn first_word(text: &str) -> &str {\n"
 "    match text.find(' ') {\n"
 "        Some(idx) => &text[..idx],\n"
@@ -12784,88 +14222,34 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable,ignore\n"
+"fn first_word(text: &str) -> &str {\n"
+"    match text.find(' ') {\n"
+"        Some(idx) => &text[..idx],\n"
+"        None => &text,\n"
+"    }\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_empty() {\n"
+"    assert_eq!(first_word(\"\"), \"\");\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_single_word() {\n"
+"    assert_eq!(first_word(\"Hello\"), \"Hello\");\n"
+"}\n"
+"\n"
+"#[test]\n"
+"fn test_multiple_words() {\n"
+"    assert_eq!(first_word(\"Hello World\"), \"Hello\");\n"
+"}\n"
+"```"
 
 #: src/testing/unit-tests.md:29
 msgid "Use `cargo test` to find and run the unit tests."
 msgstr "`cargo test` 커맨드를 사용하면 단위 테스트를 찾아서 실행합니다."
 
-#: src/testing/unit-tests.md:5
-msgid ""
-"```rust,editable,ignore\n"
-"fn first_word(text: &str) -> &str {\n"
-"    match text.find(' ') {\n"
-"        Some(idx) => &text[..idx],\n"
-"        None => &text,\n"
-"    }\n"
-"}\n"
-"\n"
-"#[test]\n"
-"fn test_empty() {\n"
-"    assert_eq!(first_word(\"\"), \"\");\n"
-"}\n"
-"\n"
-"#[test]\n"
-"fn test_single_word() {\n"
-"    assert_eq!(first_word(\"Hello\"), \"Hello\");\n"
-"}\n"
-"\n"
-"#[test]\n"
-"fn test_multiple_words() {\n"
-"    assert_eq!(first_word(\"Hello World\"), \"Hello\");\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,ignore\n"
-"fn first_word(text: &str) -> &str {\n"
-"    match text.find(' ') {\n"
-"        Some(idx) => &text[..idx],\n"
-"        None => &text,\n"
-"    }\n"
-"}\n"
-"\n"
-"#[test]\n"
-"fn test_empty() {\n"
-"    assert_eq!(first_word(\"\"), \"\");\n"
-"}\n"
-"\n"
-"#[test]\n"
-"fn test_single_word() {\n"
-"    assert_eq!(first_word(\"Hello\"), \"Hello\");\n"
-"}\n"
-"\n"
-"#[test]\n"
-"fn test_multiple_words() {\n"
-"    assert_eq!(first_word(\"Hello World\"), \"Hello\");\n"
-"}\n"
-"```"
-
-#: src/testing/useful-crates.md:1
-msgid "Useful crates for writing tests"
-msgstr "테스트 작성에 유용한 크레이트"
-
-#: src/testing/useful-crates.md:5
-msgid "Here are some additional crates which we recommend for writing tests:"
-msgstr "다음은 테스트를 작성할 때 권장되는 추가 크레이트입니다."
-
-#: src/testing/useful-crates.md:7
-msgid ""
-"[googletest](https://docs.rs/googletest): Comprehensive test assertion "
-"library in the tradition of GoogleTest for C++."
-msgstr ""
-"[googletest](https://docs.rs/googletest): C++용 GoogleTest의 방식을 따르는 테"
-"스트 라이브러리 입니다."
-
-#: src/testing/useful-crates.md:8
-msgid "[proptest](https://docs.rs/proptest): Property-based testing for Rust."
-msgstr "[proptest](https://docs.rs/proptest): Rust용 속성 기반 테스트입니다."
-
-#: src/testing/useful-crates.md:9
-msgid ""
-"[rstest](https://docs.rs/rstest): Support for fixtures and parameterised "
-"tests."
-msgstr ""
-"[rstest](https://docs.rs/rstest): 픽스처 및 매개변수화된 테스트를 지원합니다."
-
 #: src/testing/test-modules.md:3
 msgid ""
 "Unit tests are often put in a nested module (run tests on the [Playground]"
@@ -13009,6 +14393,37 @@ msgstr ""
 msgid "These tests only have access to the public API of your crate."
 msgstr "이 테스트는 크레이트의 공개 API에만 접근할 수 있습니다."
 
+#: src/testing/useful-crates.md:1
+msgid "Useful crates for writing tests"
+msgstr "테스트 작성에 유용한 크레이트"
+
+#: src/testing/useful-crates.md:3
+msgid "Rust comes with only basic support for writing tests."
+msgstr "러스트는 테스트 작성과 관련해서는 기본적인 기능만 지원합니다."
+
+#: src/testing/useful-crates.md:5
+msgid "Here are some additional crates which we recommend for writing tests:"
+msgstr "다음은 테스트를 작성할 때 권장되는 추가 크레이트입니다:"
+
+#: src/testing/useful-crates.md:7
+msgid ""
+"[googletest](https://docs.rs/googletest): Comprehensive test assertion "
+"library in the tradition of GoogleTest for C++."
+msgstr ""
+"[googletest](https://docs.rs/googletest): C++용 GoogleTest의 방식을 따르는 테"
+"스트 라이브러리 입니다."
+
+#: src/testing/useful-crates.md:8
+msgid "[proptest](https://docs.rs/proptest): Property-based testing for Rust."
+msgstr "[proptest](https://docs.rs/proptest): Rust용 속성 기반 테스트입니다."
+
+#: src/testing/useful-crates.md:9
+msgid ""
+"[rstest](https://docs.rs/rstest): Support for fixtures and parameterised "
+"tests."
+msgstr ""
+"[rstest](https://docs.rs/rstest): 픽스처 및 매개변수화된 테스트를 지원합니다."
+
 #: src/unsafe.md:3
 msgid "The Rust language has two parts:"
 msgstr "러스트로 작성된 프로그램은 크게 두 부분으로 나뉩니다:"
@@ -13054,15 +14469,15 @@ msgstr "원시 포인터 역참조(따라가기)"
 
 #: src/unsafe.md:17
 msgid "Access or modify mutable static variables."
-msgstr "정적 가변변수 접근 및 수정"
+msgstr "정적 가변변수 접근 및 수정."
 
 #: src/unsafe.md:18
 msgid "Access `union` fields."
-msgstr "`union` 필드 접근"
+msgstr "`union` 필드 접근."
 
 #: src/unsafe.md:19
 msgid "Call `unsafe` functions, including `extern` functions."
-msgstr "`extern` 함수를 포함한 `unsafe` 함수 호출"
+msgstr "`extern` 함수를 포함한 `unsafe` 함수 호출."
 
 #: src/unsafe.md:20
 msgid "Implement `unsafe` traits."
@@ -13105,12 +14520,11 @@ msgid ""
 "    let r1 = &mut num as *mut i32;\n"
 "    let r2 = r1 as *const i32;\n"
 "\n"
-"    // Safe because r1 and r2 were obtained from references and so are "
-"guaranteed to be non-null and\n"
-"    // properly aligned, the objects underlying the references from which "
-"they were obtained are\n"
-"    // live throughout the whole unsafe block, and they are not accessed "
-"either through the\n"
+"    // Safe because r1 and r2 were obtained from references and so are\n"
+"    // guaranteed to be non-null and properly aligned, the objects "
+"underlying\n"
+"    // the references from which they were obtained are live throughout the\n"
+"    // whole unsafe block, and they are not accessed either through the\n"
 "    // references or concurrently through any other pointers.\n"
 "    unsafe {\n"
 "        println!(\"r1 is: {}\", *r1);\n"
@@ -13127,13 +14541,12 @@ msgstr ""
 "    let r1 = &mut num as *mut i32;\n"
 "    let r2 = r1 as *const i32;\n"
 "\n"
-"    // 아래 코드는 안전합니다. r1과 r2는 참조로 부터 만들어 졌기 때문에 null"
-"이 아니며\n"
-"    // align이 맞다는 것이 보장됩니다. 참조가 가리키는 객체들은 unsafe 블럭"
-"이 수행되는\n"
-"    // 동안 메모리에 살아있습니다. 그리고 이 객체들은 r1과 r2가 아닌 다른 어"
-"떤 참조나\n"
-"    // 포인터로도 접근이 안되고 있습니다.\n"
+"    // Safe because r1 and r2 were obtained from references and so are\n"
+"    // guaranteed to be non-null and properly aligned, the objects "
+"underlying\n"
+"    // the references from which they were obtained are live throughout the\n"
+"    // whole unsafe block, and they are not accessed either through the\n"
+"    // references or concurrently through any other pointers.\n"
 "    unsafe {\n"
 "        println!(\"r1 is: {}\", *r1);\n"
 "        *r1 = 10;\n"
@@ -13142,7 +14555,7 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/unsafe/raw-pointers.md:26
+#: src/unsafe/raw-pointers.md:27
 msgid ""
 "It is good practice (and required by the Android Rust style guide) to write "
 "a comment for each `unsafe` block explaining how the code inside it "
@@ -13152,7 +14565,7 @@ msgstr ""
 "것은 좋은 습관입니다(사실 안드로이드의 러스트 스타일 가이드에서는 이게 필수입"
 "니다)."
 
-#: src/unsafe/raw-pointers.md:30
+#: src/unsafe/raw-pointers.md:31
 msgid ""
 "In the case of pointer dereferences, this means that the pointers must be "
 "[_valid_](https://doc.rust-lang.org/std/ptr/index.html#safety), i.e.:"
@@ -13160,11 +14573,11 @@ msgstr ""
 "포인터 역참조를 할 경우, 포인터가 [_유효_](https://doc.rust-lang.org/std/ptr/"
 "index.html#safety)해야 합니다. 예를 들어:"
 
-#: src/unsafe/raw-pointers.md:33
+#: src/unsafe/raw-pointers.md:34
 msgid "The pointer must be non-null."
 msgstr "포인터는 null이면 안됩니다."
 
-#: src/unsafe/raw-pointers.md:34
+#: src/unsafe/raw-pointers.md:35
 msgid ""
 "The pointer must be _dereferenceable_ (within the bounds of a single "
 "allocated object)."
@@ -13172,15 +14585,15 @@ msgstr ""
 "포인터는 따라가기가 가능해야 합니다 (객체의 어느 한 부분을 가리키고 있어야 합"
 "니다)."
 
-#: src/unsafe/raw-pointers.md:35
+#: src/unsafe/raw-pointers.md:36
 msgid "The object must not have been deallocated."
 msgstr "이미 반환된 객체를 가리키면 안됩니다."
 
-#: src/unsafe/raw-pointers.md:36
+#: src/unsafe/raw-pointers.md:37
 msgid "There must not be concurrent accesses to the same location."
 msgstr "같은 위치에 대해 동시적인 접근이 있으면 안됩니다."
 
-#: src/unsafe/raw-pointers.md:37
+#: src/unsafe/raw-pointers.md:38
 msgid ""
 "If the pointer was obtained by casting a reference, the underlying object "
 "must be live and no reference may be used to access the memory."
@@ -13188,7 +14601,7 @@ msgstr ""
 "참조를 캐스팅 해서 포인터를 만들었다면, 그 참조가 가리키는 객체는 살아 있어"
 "야 하며, 그 객체의 메모리를 접근하는 참조가 하나도 없어야 합니다."
 
-#: src/unsafe/raw-pointers.md:40
+#: src/unsafe/raw-pointers.md:41
 msgid "In most cases the pointer must also be properly aligned."
 msgstr "대부분의 경우 포인터는 align되어 있어야 합니다."
 
@@ -13455,10 +14868,10 @@ msgid ""
 "`unsafe` block. We can prohibit this with `#[deny(unsafe_op_in_unsafe_fn)]`. "
 "Try adding it and see what happens."
 msgstr ""
-"unsafe 코드가 unsafe 함수의 내부에서 호출될 경우에는 `unsafe`블록을 지정하지 "
-"않아도 됩니다. `unsafe`블록을 항상 지정하도록 하고 싶다면 "
-"`#[deny(unsafe_op_in_unsafe_fn)]`를 이용하세요. 이 어트리뷰트를 추가해 보고 "
-"어떤 일이 일어나는지 확인해 보세요."
+"안전하지 않은(unsafe) 코드가 안전하지 않은(unsafe) 함수의 내부에서 호출될 경"
+"우에는 `unsafe`블록을 지정하지 않아도 됩니다. `unsafe`블록을 항상 지정하도록 "
+"하고 싶다면 `#[deny(unsafe_op_in_unsafe_fn)]`를 이용하세요. 이 어트리뷰트를 "
+"추가해 보고 어떤 일이 일어나는지 확인해 보세요."
 
 #: src/unsafe/extern-functions.md:1
 msgid "Calling External Code"
@@ -13603,7 +15016,23 @@ msgstr "3일차 오후 연습문제"
 msgid "Let us build a safe wrapper for reading directory content!"
 msgstr "디렉터리의 내용을 읽는 안전한 래퍼 코드를 작성해 봅시다!"
 
-#: src/exercises/day-3/afternoon.md:7
+#: src/exercises/day-3/afternoon.md:5
+msgid ""
+"For this exercise, we suggest using a local dev environment instead of the "
+"Playground. This will allow you to run your binary on your own machine."
+msgstr ""
+"이번 연습에서는, 플레이그라운드 대신 로컬 개발 환경을 사용해서, 여러분의 컴퓨"
+"터에서 바이너리를 직접 수행해 보세요."
+
+#: src/exercises/day-3/afternoon.md:8
+msgid ""
+"To get started, follow the [running locally](../../cargo/running-locally.md) "
+"instructions."
+msgstr ""
+"시작하기 위해, [로컬 환경에서 수행하기](../../cargo/running-locally.md)를 따"
+"르세요."
+
+#: src/exercises/day-3/afternoon.md:14
 msgid ""
 "After looking at the exercise, you can look at the [solution](solutions-"
 "afternoon.md) provided."
@@ -13639,20 +15068,130 @@ msgstr "[`closedir(3)`](https://man7.org/linux/man-pages/man3/closedir.3.html)"
 #: src/exercises/day-3/safe-ffi-wrapper.md:13
 msgid ""
 "You will also want to browse the [`std::ffi`](https://doc.rust-lang.org/std/"
-"ffi/) module, particular for [`CStr`](https://doc.rust-lang.org/std/ffi/"
-"struct.CStr.html) and [`CString`](https://doc.rust-lang.org/std/ffi/struct."
-"CString.html) types which are used to hold NUL-terminated strings coming "
-"from C. The [Nomicon](https://doc.rust-lang.org/nomicon/ffi.html) also has a "
-"very useful chapter about FFI."
+"ffi/) module. There you find a number of string types which you need for the "
+"exercise:"
 msgstr ""
-"[`std::ffi`](https://doc.rust-lang.org/std/ffi/) 모듈을 탐색하는게 필요할 지"
-"도 모르겠습니다. C에서 사용되는 NUL-terminated 문자열을 담기 위한 [`CStr`]"
-"(https://doc.rust-lang.org/std/ffi/struct.CStr.html)과 [`CString`](https://"
-"doc.rust-lang.org/std/ffi/struct.CString.html) 타입을 확인해 보세요. "
-"[Nomicon](https://doc.rust-lang.org/nomicon/ffi.html)문서 또한 FFI에 대한 유"
-"용한 내용을 담고 있습니다."
+"아마 [`std::ffi`](https://doc.rust-lang.org/std/ffi/)모듈을 참조할 필요가 있"
+"을 것입니다. 거기에는 이번 예제를 수행하는데 필요한 다양한 종류의 문자열 타입"
+"들이 소개되어 있습니다:"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:16
+msgid "Encoding"
+msgstr "인코딩"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:16
+msgid "Use"
+msgstr "사용"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:18
+msgid ""
+"[`str`](https://doc.rust-lang.org/std/primitive.str.html) and [`String`]"
+"(https://doc.rust-lang.org/std/string/struct.String.html)"
+msgstr ""
+"[`str`](https://doc.rust-lang.org/std/primitive.str.html)과 [`String`]"
+"(https://doc.rust-lang.org/std/string/struct.String.html)"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:18
+msgid "UTF-8"
+msgstr "UTF-8"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:18
+msgid "Text processing in Rust"
+msgstr "러스트에서의 문자열 처리"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:19
+msgid ""
+"[`CStr`](https://doc.rust-lang.org/std/ffi/struct.CStr.html) and [`CString`]"
+"(https://doc.rust-lang.org/std/ffi/struct.CString.html)"
+msgstr ""
+"[`CStr`](https://doc.rust-lang.org/std/ffi/struct.CStr.html)과 [`CString`]"
+"(https://doc.rust-lang.org/std/ffi/struct.CString.html)"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:19
+msgid "NUL-terminated"
+msgstr "널(NUL)로 끝남"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:19
+msgid "Communicating with C functions"
+msgstr "C함수와 연동하기"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:20
+msgid ""
+"[`OsStr`](https://doc.rust-lang.org/std/ffi/struct.OsStr.html) and "
+"[`OsString`](https://doc.rust-lang.org/std/ffi/struct.OsString.html)"
+msgstr ""
+"[`OsStr`](https://doc.rust-lang.org/std/ffi/struct.OsStr.html)와 [`OsString`]"
+"(https://doc.rust-lang.org/std/ffi/struct.OsString.html)"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:20
+msgid "OS-specific"
+msgstr "OS가 정의함"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:20
+msgid "Communicating with the OS"
+msgstr "OS와 연동하기 위한 문자열"
 
 #: src/exercises/day-3/safe-ffi-wrapper.md:22
+msgid "You will convert between all these types:"
+msgstr "이 타입들 간의 변환은 다음과 같습니다:"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:24
+msgid ""
+"`&str` to `CString`: you need to allocate space for a trailing `\\0` "
+"character,"
+msgstr ""
+"`&str`에서 `CString`으로의 변환: 맨 마지막의 `\\0` 문자를 저장하기 위한 공간"
+"을 할당해야 합니다,"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:25
+msgid "`CString` to `*const i8`: you need a pointer to call C functions,"
+msgstr ""
+"`CString`에서 `*const i8`로의 변환: C함수를 호출하기 위해서는 포인터가 필요합"
+"니다,"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:26
+msgid ""
+"`*const i8` to `&CStr`: you need something which can find the trailing `\\0` "
+"character,"
+msgstr ""
+"`*const i8`에서 `&CStr`로의 변환: 주어진 바이트 시퀀스가 `\\0`로 끝나는지 확"
+"인하고 싶은 경우,"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:27
+msgid ""
+"`&CStr` to `&[u8]`: a slice of bytes is the universal interface for \"some "
+"unknow data\","
+msgstr ""
+"`&CStr`에서 `&[u8]`로의 변환: 바이트 슬라이스는 \"알수없는 데이터\"에 대한 일"
+"반적인 인터페이스입니다,"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:28
+msgid ""
+"`&[u8]` to `&OsStr`: `&OsStr` is a step towards `OsString`, use [`OsStrExt`]"
+"(https://doc.rust-lang.org/std/os/unix/ffi/trait.OsStrExt.html) to create it,"
+msgstr ""
+"`&[u8]`에서 `&OsStr`로의 변환: `&OsStr`는 `OsString`으로 가기 위한 중간 단계 "
+"입니다. [`OsStrExt`](https://doc.rust-lang.org/std/os/unix/ffi/trait."
+"OsStrExt.html)를 사용해서  `OsStr`를 생성하세요,"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:31
+msgid ""
+"`&OsStr` to `OsString`: you need to clone the data in `&OsStr` to be able to "
+"return it and call `readdir` again."
+msgstr ""
+"`&OsStr`에서 `OsString`으로의 변환: `&OsStr`이 가리키고 있는 데이터를 복사함"
+"으로써, 이 데이터를 리턴하고, `readdir`함수를 호출할 때 사용할 수 있게 해 줍"
+"니다."
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:34
+msgid ""
+"The [Nomicon](https://doc.rust-lang.org/nomicon/ffi.html) also has a very "
+"useful chapter about FFI."
+msgstr ""
+"[Nomicon](https://doc.rust-lang.org/nomicon/ffi.html)에 FFI와 관련한 아주 유"
+"용한 챕터가 있습니다."
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:45
 msgid ""
 "Copy the code below to <https://play.rust-lang.org/> and fill in the missing "
 "functions and methods:"
@@ -13660,14 +15199,16 @@ msgstr ""
 "아래 코드를 <https://play.rust-lang.org/>에 복사하고 빠진 함수와 메서드를 채"
 "워봅니다:"
 
-#: src/exercises/day-3/safe-ffi-wrapper.md:25
+#: src/exercises/day-3/safe-ffi-wrapper.md:48
 msgid ""
 "```rust,should_panic\n"
 "// TODO: remove this when you're done with your implementation.\n"
 "#![allow(unused_imports, unused_variables, dead_code)]\n"
 "\n"
 "mod ffi {\n"
-"    use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};\n"
+"    use std::os::raw::{c_char, c_int};\n"
+"    #[cfg(not(target_os = \"macos\"))]\n"
+"    use std::os::raw::{c_long, c_ulong, c_ushort, c_uchar};\n"
 "\n"
 "    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.\n"
 "    #[repr(C)]\n"
@@ -13677,20 +15218,50 @@ msgid ""
 "PhantomPinned)>,\n"
 "    }\n"
 "\n"
-"    // Layout as per readdir(3) and definitions in /usr/include/x86_64-linux-"
-"gnu.\n"
+"    // Layout according to the Linux man page for readdir(3), where ino_t "
+"and\n"
+"    // off_t are resolved according to the definitions in\n"
+"    // /usr/include/x86_64-linux-gnu/{sys/types.h, bits/typesizes.h}.\n"
+"    #[cfg(not(target_os = \"macos\"))]\n"
 "    #[repr(C)]\n"
 "    pub struct dirent {\n"
-"        pub d_ino: c_long,\n"
-"        pub d_off: c_ulong,\n"
+"        pub d_ino: c_ulong,\n"
+"        pub d_off: c_long,\n"
 "        pub d_reclen: c_ushort,\n"
-"        pub d_type: c_char,\n"
+"        pub d_type: c_uchar,\n"
 "        pub d_name: [c_char; 256],\n"
 "    }\n"
 "\n"
+"    // Layout according to the macOS man page for dir(5).\n"
+"    #[cfg(all(target_os = \"macos\"))]\n"
+"    #[repr(C)]\n"
+"    pub struct dirent {\n"
+"        pub d_fileno: u64,\n"
+"        pub d_seekoff: u64,\n"
+"        pub d_reclen: u16,\n"
+"        pub d_namlen: u16,\n"
+"        pub d_type: u8,\n"
+"        pub d_name: [c_char; 1024],\n"
+"    }\n"
+"\n"
 "    extern \"C\" {\n"
 "        pub fn opendir(s: *const c_char) -> *mut DIR;\n"
+"\n"
+"        #[cfg(not(all(target_os = \"macos\", target_arch = \"x86_64\")))]\n"
 "        pub fn readdir(s: *mut DIR) -> *const dirent;\n"
+"\n"
+"        // See https://github.com/rust-lang/libc/issues/414 and the section "
+"on\n"
+"        // _DARWIN_FEATURE_64_BIT_INODE in the macOS man page for stat(2).\n"
+"        //\n"
+"        // \"Platforms that existed before these updates were available\" "
+"refers\n"
+"        // to macOS (as opposed to iOS / wearOS / etc.) on Intel and "
+"PowerPC.\n"
+"        #[cfg(all(target_os = \"macos\", target_arch = \"x86_64\"))]\n"
+"        #[link_name = \"readdir$INODE64\"]\n"
+"        pub fn readdir(s: *mut DIR) -> *const dirent;\n"
+"\n"
 "        pub fn closedir(s: *mut DIR) -> c_int;\n"
 "    }\n"
 "}\n"
@@ -13734,2790 +15305,114 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
-
-#: src/welcome-day-4.md:1
-msgid "Welcome to Day 4"
-msgstr "4일차 개요"
-
-#: src/welcome-day-4.md:3
-msgid ""
-"This morning, we will focus on Concurrency: threads, channels, shared state, "
-"`Send` and `Sync`. In the afternoon, we will have a chance to see Rust in "
-"action."
-msgstr ""
-"오전에는 동시성을 다룹니다: 쓰레드, 채널, 공유 상태, `Send`와 `Sync`. 오후에"
-"는 러스트가 실제 사용되는 사례를 살펴봅니다."
-
-#: src/welcome-day-4.md:8
-msgid ""
-"This is a good time to give an outline of what you will cover in the "
-"afternoon section, as announced in the course offering."
-msgstr "오후에 다룰 내용의 개요를 소개하는 것도 좋습니다."
-
-#: src/concurrency.md:1
-msgid "Fearless Concurrency"
-msgstr "겂없는 동시성"
-
-#: src/concurrency.md:3
-msgid ""
-"Rust has full support for concurrency using OS threads with mutexes and "
-"channels."
-msgstr ""
-"러스트는 동시성 지원이 막강합니다. 운영체제 레벨의 스레드를 사용하며, 뮤택스"
-"와 채널도 지원합니다."
-
-#: src/concurrency.md:6
-msgid ""
-"The Rust type system plays an important role in making many concurrency bugs "
-"compile time bugs. This is often referred to as _fearless concurrency_ since "
-"you can rely on the compiler to ensure correctness at runtime."
-msgstr ""
-"러스트의 타입 시스템은 프로그램에 동시성 버그가 있을 경우, 컴파일 시에 에러"
-"가 발생하도록 해 줍니다. 컴파일러를 이용해서 프로그램이 수행시에 정확히 동작"
-"함을 미리 보장해 주기 때문에, 사람들은 이를 종종 _겁없는 동시성_ 이라고 합니"
-"다."
-
-#: src/concurrency/threads.md:3
-msgid "Rust threads work similarly to threads in other languages:"
-msgstr "러스트의 스레드는 다른 언어의 스레드와 유사하게 동작합니다:"
-
-#: src/concurrency/threads.md:5
-msgid ""
-"```rust,editable\n"
-"use std::thread;\n"
-"use std::time::Duration;\n"
+"```rust,should_panic\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_imports, unused_variables, dead_code)]\n"
 "\n"
-"fn main() {\n"
-"    thread::spawn(|| {\n"
-"        for i in 1..10 {\n"
-"            println!(\"Count in thread: {i}!\");\n"
-"            thread::sleep(Duration::from_millis(5));\n"
-"        }\n"
-"    });\n"
+"mod ffi {\n"
+"    use std::os::raw::{c_char, c_int};\n"
+"    #[cfg(not(target_os = \"macos\"))]\n"
+"    use std::os::raw::{c_long, c_ulong, c_ushort, c_uchar};\n"
 "\n"
-"    for i in 1..5 {\n"
-"        println!(\"Main thread: {i}\");\n"
-"        thread::sleep(Duration::from_millis(5));\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"use std::thread;\n"
-"use std::time::Duration;\n"
-"\n"
-"fn main() {\n"
-"    thread::spawn(|| {\n"
-"        for i in 1..10 {\n"
-"            println!(\"Count in thread: {i}!\");\n"
-"            thread::sleep(Duration::from_millis(5));\n"
-"        }\n"
-"    });\n"
-"\n"
-"    for i in 1..5 {\n"
-"        println!(\"Main thread: {i}\");\n"
-"        thread::sleep(Duration::from_millis(5));\n"
-"    }\n"
-"}\n"
-"```"
-
-#: src/concurrency/threads.md:24
-msgid "Threads are all daemon threads, the main thread does not wait for them."
-msgstr ""
-"스레드는 모두 데몬 스레드입니다. 따라서 메인 스레드는 이 스레드들이 끝나기를 "
-"기다리지 않습니다."
-
-#: src/concurrency/threads.md:25
-msgid "Thread panics are independent of each other."
-msgstr "한 스레드에서 발생한 패닉은 다른 스레드에게 영향을 끼치지 않습니다."
-
-#: src/concurrency/threads.md:26
-msgid "Panics can carry a payload, which can be unpacked with `downcast_ref`."
-msgstr ""
-"패닉은 추가정보(페이로드)를 포함할 수 있으며, 이는 `downcast_ref`로 풀어볼 "
-"수 있습니다."
-
-#: src/concurrency/threads.md:32
-msgid ""
-"Notice that the thread is stopped before it reaches 10 — the main thread is "
-"not waiting."
-msgstr ""
-"메인 스레드가 자식 스레드를 기다리지 않기 때문에 자식 스레드의 for문은 10까"
-"지 가지 않습니다."
-
-#: src/concurrency/threads.md:35
-msgid ""
-"Use `let handle = thread::spawn(...)` and later `handle.join()` to wait for "
-"the thread to finish."
-msgstr ""
-"만약 메인 스레드가 자식 스레드가 끝날 때 까지 기다리기를 원한다면 `let "
-"handle = thread::spawn(...)`으로 스레드를 선언한 후 `handle.join()`로 연결하"
-"여 사용합니다."
-
-#: src/concurrency/threads.md:38
-msgid "Trigger a panic in the thread, notice how this doesn't affect `main`."
-msgstr ""
-"자식 스레드에서 발생한 패닉이 메인 스레드에는 영향을 주지 않음을 확인하시기 "
-"바랍니다."
-
-#: src/concurrency/threads.md:40
-msgid ""
-"Use the `Result` return value from `handle.join()` to get access to the "
-"panic payload. This is a good time to talk about [`Any`](https://doc.rust-"
-"lang.org/std/any/index.html)."
-msgstr ""
-"`handle.join()`사용시 `Result` 반환값을 통해 패닉의 추가정보에 접근할 수 있습"
-"니다. 이 시점에서 [`Any`](https://doc.rust-lang.org/std/any/index.html)에 대"
-"해 이야기를 해 보면 좋습니다."
-
-#: src/concurrency/scoped-threads.md:3
-msgid "Normal threads cannot borrow from their environment:"
-msgstr "보통, 스레드는 스레드 밖에서 데이터를 빌릴 수 없습니다:"
-
-#: src/concurrency/scoped-threads.md:5
-msgid ""
-"```rust,editable,compile_fail\n"
-"use std::thread;\n"
-"\n"
-"fn main() {\n"
-"    let s = String::from(\"Hello\");\n"
-"\n"
-"    thread::spawn(|| {\n"
-"        println!(\"Length: {}\", s.len());\n"
-"    });\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use std::thread;\n"
-"\n"
-"fn main() {\n"
-"    let s = String::from(\"Hello\");\n"
-"\n"
-"    thread::spawn(|| {\n"
-"        println!(\"Length: {}\", s.len());\n"
-"    });\n"
-"}\n"
-"```"
-
-#: src/concurrency/scoped-threads.md:17
-msgid ""
-"However, you can use a [scoped thread](https://doc.rust-lang.org/std/thread/"
-"fn.scope.html) for this:"
-msgstr ""
-"하지만, [scoped thread](https://doc.rust-lang.org/std/thread/fn.scope.html)에"
-"서는 가능합니다:"
-
-#: src/concurrency/scoped-threads.md:19
-msgid ""
-"```rust,editable\n"
-"use std::thread;\n"
-"\n"
-"fn main() {\n"
-"    let s = String::from(\"Hello\");\n"
-"\n"
-"    thread::scope(|scope| {\n"
-"        scope.spawn(|| {\n"
-"            println!(\"Length: {}\", s.len());\n"
-"        });\n"
-"    });\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"use std::thread;\n"
-"\n"
-"fn main() {\n"
-"    let s = String::from(\"Hello\");\n"
-"\n"
-"    thread::scope(|scope| {\n"
-"        scope.spawn(|| {\n"
-"            println!(\"Length: {}\", s.len());\n"
-"        });\n"
-"    });\n"
-"}\n"
-"```"
-
-#: src/concurrency/scoped-threads.md:37
-msgid ""
-"The reason for that is that when the `thread::scope` function completes, all "
-"the threads are guaranteed to be joined, so they can return borrowed data."
-msgstr ""
-"`thread::scope` 함수가 완료되면 그 안에서 생성된 모든 스레드들이 종료했음이 "
-"보장되기 때문에, 그 때 빌렸던 데이터들을 다시 반환할 수 있기 때문입니다."
-
-#: src/concurrency/scoped-threads.md:38
-msgid ""
-"Normal Rust borrowing rules apply: you can either borrow mutably by one "
-"thread, or immutably by any number of threads."
-msgstr ""
-"일반적인 러스트의 빌림 규칙이 적용됩니다: 한 스레드에 의한 가변 빌림 또는 여"
-"러 스레드에 대한 불변 빌림중 하나만 가능합니다."
-
-#: src/concurrency/channels.md:3
-msgid ""
-"Rust channels have two parts: a `Sender<T>` and a `Receiver<T>`. The two "
-"parts are connected via the channel, but you only see the end-points."
-msgstr ""
-"러스트의 채널은 `Sender<T>` 와 `Receiver<T>` 두 부분으로 구성됩니다. 이 둘은 "
-"채널을 통해 서로 연결되어 있지만, 우리는 채널을 볼 수는 없고 이 양 끝단만을 "
-"사용하게 됩니다."
-
-#: src/concurrency/channels.md:6
-msgid ""
-"```rust,editable\n"
-"use std::sync::mpsc;\n"
-"use std::thread;\n"
-"\n"
-"fn main() {\n"
-"    let (tx, rx) = mpsc::channel();\n"
-"\n"
-"    tx.send(10).unwrap();\n"
-"    tx.send(20).unwrap();\n"
-"\n"
-"    println!(\"Received: {:?}\", rx.recv());\n"
-"    println!(\"Received: {:?}\", rx.recv());\n"
-"\n"
-"    let tx2 = tx.clone();\n"
-"    tx2.send(30).unwrap();\n"
-"    println!(\"Received: {:?}\", rx.recv());\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"use std::sync::mpsc;\n"
-"use std::thread;\n"
-"\n"
-"fn main() {\n"
-"    let (tx, rx) = mpsc::channel();\n"
-"\n"
-"    tx.send(10).unwrap();\n"
-"    tx.send(20).unwrap();\n"
-"\n"
-"    println!(\"Received: {:?}\", rx.recv());\n"
-"    println!(\"Received: {:?}\", rx.recv());\n"
-"\n"
-"    let tx2 = tx.clone();\n"
-"    tx2.send(30).unwrap();\n"
-"    println!(\"Received: {:?}\", rx.recv());\n"
-"}\n"
-"```"
-
-#: src/concurrency/channels.md:27
-msgid ""
-"`mpsc` stands for Multi-Producer, Single-Consumer. `Sender` and `SyncSender` "
-"implement `Clone` (so you can make multiple producers) but `Receiver` does "
-"not."
-msgstr ""
-"`mpsc`는 “Multi-Produce, Single-Consumer”를 의미합니다. `Sender`와 "
-"`SyncSender`는 `Clone`을 구현하지만 (즉, 여러개의 producer를 만들수 있습니"
-"다) `Receiver`는 `Clone`을 구현하지 않습니다."
-
-#: src/concurrency/channels.md:29
-msgid ""
-"`send()` and `recv()` return `Result`. If they return `Err`, it means the "
-"counterpart `Sender` or `Receiver` is dropped and the channel is closed."
-msgstr ""
-"`send()`와 `recv()`는 `Result`를 반환합니다. 만일 `Err`가 반환된다면, 상대방"
-"의 `Sender`또는 `Receiver`가 삭제되었고 채널이 닫혔다는 뜻입니다."
-
-#: src/concurrency/channels/unbounded.md:3
-msgid "You get an unbounded and asynchronous channel with `mpsc::channel()`:"
-msgstr "`mpsc::channel()` 함수는 경계가 없는 비동기 채널을 생성합니다:"
-
-#: src/concurrency/channels/unbounded.md:5
-msgid ""
-"```rust,editable\n"
-"use std::sync::mpsc;\n"
-"use std::thread;\n"
-"use std::time::Duration;\n"
-"\n"
-"fn main() {\n"
-"    let (tx, rx) = mpsc::channel();\n"
-"\n"
-"    thread::spawn(move || {\n"
-"        let thread_id = thread::current().id();\n"
-"        for i in 1..10 {\n"
-"            tx.send(format!(\"Message {i}\")).unwrap();\n"
-"            println!(\"{thread_id:?}: sent Message {i}\");\n"
-"        }\n"
-"        println!(\"{thread_id:?}: done\");\n"
-"    });\n"
-"    thread::sleep(Duration::from_millis(100));\n"
-"\n"
-"    for msg in rx.iter() {\n"
-"        println!(\"Main: got {}\", msg);\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/concurrency/channels/unbounded.md:5
-msgid ""
-"```rust,editable\n"
-"use std::sync::mpsc;\n"
-"use std::thread;\n"
-"use std::time::Duration;\n"
-"\n"
-"fn main() {\n"
-"    let (tx, rx) = mpsc::channel();\n"
-"\n"
-"    thread::spawn(move || {\n"
-"        let thread_id = thread::current().id();\n"
-"        for i in 1..10 {\n"
-"            tx.send(format!(\"Message {i}\")).unwrap();\n"
-"            println!(\"{thread_id:?}: sent Message {i}\");\n"
-"        }\n"
-"        println!(\"{thread_id:?}: done\");\n"
-"    });\n"
-"    thread::sleep(Duration::from_millis(100));\n"
-"\n"
-"    for msg in rx.iter() {\n"
-"        println!(\"Main: got {msg}\");\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"use std::sync::mpsc;\n"
-"use std::thread;\n"
-"use std::time::Duration;\n"
-"\n"
-"fn main() {\n"
-"    let (tx, rx) = mpsc::channel();\n"
-"\n"
-"    thread::spawn(move || {\n"
-"        let thread_id = thread::current().id();\n"
-"        for i in 1..10 {\n"
-"            tx.send(format!(\"Message {i}\")).unwrap();\n"
-"            println!(\"{thread_id:?}: sent Message {i}\");\n"
-"        }\n"
-"        println!(\"{thread_id:?}: done\");\n"
-"    });\n"
-"    thread::sleep(Duration::from_millis(100));\n"
-"\n"
-"    for msg in rx.iter() {\n"
-"        println!(\"Main: got {msg}\");\n"
-"    }\n"
-"}\n"
-"```"
-
-#: src/concurrency/channels/bounded.md:3
-msgid "Bounded and synchronous channels make `send` block the current thread:"
-msgstr "경계가 있는 동기 채널은 `send`가 현제 스레드를 블로킹 하도록 만듭니다:"
-
-#: src/concurrency/channels/bounded.md:5
-msgid ""
-"```rust,editable\n"
-"use std::sync::mpsc;\n"
-"use std::thread;\n"
-"use std::time::Duration;\n"
-"\n"
-"fn main() {\n"
-"    let (tx, rx) = mpsc::sync_channel(3);\n"
-"\n"
-"    thread::spawn(move || {\n"
-"        let thread_id = thread::current().id();\n"
-"        for i in 1..10 {\n"
-"            tx.send(format!(\"Message {i}\")).unwrap();\n"
-"            println!(\"{thread_id:?}: sent Message {i}\");\n"
-"        }\n"
-"        println!(\"{thread_id:?}: done\");\n"
-"    });\n"
-"    thread::sleep(Duration::from_millis(100));\n"
-"\n"
-"    for msg in rx.iter() {\n"
-"        println!(\"Main: got {msg}\");\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"use std::sync::mpsc;\n"
-"use std::thread;\n"
-"use std::time::Duration;\n"
-"\n"
-"fn main() {\n"
-"    let (tx, rx) = mpsc::sync_channel(3);\n"
-"\n"
-"    thread::spawn(move || {\n"
-"        let thread_id = thread::current().id();\n"
-"        for i in 1..10 {\n"
-"            tx.send(format!(\"Message {i}\")).unwrap();\n"
-"            println!(\"{thread_id:?}: sent Message {i}\");\n"
-"        }\n"
-"        println!(\"{thread_id:?}: done\");\n"
-"    });\n"
-"    thread::sleep(Duration::from_millis(100));\n"
-"\n"
-"    for msg in rx.iter() {\n"
-"        println!(\"Main: got {msg}\");\n"
-"    }\n"
-"}\n"
-"```"
-
-#: src/concurrency/shared_state.md:3
-msgid ""
-"Rust uses the type system to enforce synchronization of shared data. This is "
-"primarily done via two types:"
-msgstr ""
-"러스트는 주로 아래 두 가지 타입을 이용해서 공유 데이터 동기화를 수행합니다:"
-
-#: src/concurrency/shared_state.md:6
-msgid ""
-"[`Arc<T>`](https://doc.rust-lang.org/std/sync/struct.Arc.html), atomic "
-"reference counted `T`: handles sharing between threads and takes care to "
-"deallocate `T` when the last reference is dropped,"
-msgstr ""
-"[`Arc<T>`](https://doc.rust-lang.org/std/sync/struct.Arc.html), `T`에 대한 아"
-"토믹 참조 카운트: 이 참조는 다수의 스레드 사이에서 공유될 수 있고, 참조하던 "
-"마지막 스레드가 종료할 경우 `T`를 반환합니다."
-
-#: src/concurrency/shared_state.md:8
-msgid ""
-"[`Mutex<T>`](https://doc.rust-lang.org/std/sync/struct.Mutex.html): ensures "
-"mutually exclusive access to the `T` value."
-msgstr ""
-"[`Mutex<T>`](https://doc.rust-lang.org/std/sync/struct.Mutex.html): `T`값에 "
-"대한 상호 배제 엑세스를 보장합니다."
-
-#: src/concurrency/shared_state/arc.md:1
-msgid "`Arc`"
-msgstr "`Arc`"
-
-#: src/concurrency/shared_state/arc.md:3
-msgid ""
-"[`Arc<T>`](https://doc.rust-lang.org/std/sync/struct.Arc.html) allows shared "
-"read-only access via its `clone` method:"
-msgstr ""
-"[`Arc<T>`](https://doc.rust-lang.org/std/sync/struct.Arc.html)의 `clone` 메서"
-"드를 이용하면 여러 스레드가 한 데이터를 동시에 (_역주_: 그리고 안전하게. 스레"
-"드가 하나라도 살아있는 동안에는 `T`가 반환되지 않음) 읽을 수 있습니다:"
-
-#: src/concurrency/shared_state/arc.md:5
-msgid ""
-"```rust,editable\n"
-"use std::thread;\n"
-"use std::sync::Arc;\n"
-"\n"
-"fn main() {\n"
-"    let v = Arc::new(vec![10, 20, 30]);\n"
-"    let mut handles = Vec::new();\n"
-"    for _ in 1..5 {\n"
-"        let v = v.clone();\n"
-"        handles.push(thread::spawn(move || {\n"
-"            let thread_id = thread::current().id();\n"
-"            println!(\"{thread_id:?}: {v:?}\");\n"
-"        }));\n"
+"    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.\n"
+"    #[repr(C)]\n"
+"    pub struct DIR {\n"
+"        _data: [u8; 0],\n"
+"        _marker: core::marker::PhantomData<(*mut u8, core::marker::"
+"PhantomPinned)>,\n"
 "    }\n"
 "\n"
-"    handles.into_iter().for_each(|h| h.join().unwrap());\n"
-"    println!(\"v: {v:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/concurrency/shared_state/arc.md:29
-msgid ""
-"`Arc` stands for \"Atomic Reference Counted\", a thread safe version of `Rc` "
-"that uses atomic operations."
-msgstr ""
-"`Arc`는 \"Atomic Reference Counted\"를 의미하며, 스레드 안정성을 보장하는 "
-"`Rc`라고 생각하면 됩니다."
-
-#: src/concurrency/shared_state/arc.md:31
-msgid ""
-"`Arc<T>` implements `Clone` whether or not `T` does. It implements `Send` "
-"and `Sync` iff `T` implements them both."
-msgstr ""
-"`T`가 `Clone`을 구현하든 안하든 `Arc<T>`는 `Clone`을 구현합니다. `Send`와 "
-"`Sync`는 `T`가 이들을 구현하는 경우에만 구현됩니다."
-
-#: src/concurrency/shared_state/arc.md:33
-msgid ""
-"`Arc::clone()` has the cost of atomic operations that get executed, but "
-"after that the use of the `T` is free."
-msgstr ""
-"`Arc::clone()`는 아토믹 연산을 수행하기 때문에 그 때 코스트가 좀 있지만, 일"
-"단 `clone()`이 끝난 후 `T`를 사용하는 대에는 아무런 오버헤드가 없습니다."
-
-#: src/concurrency/shared_state/arc.md:35
-msgid ""
-"Beware of reference cycles, `Arc` does not use a garbage collector to detect "
-"them."
-msgstr ""
-"순환 참조가 발생하지 않도록 주의해야 합니다. 러스트는 순환 참조를 감지하는 가"
-"비지 컬랙터가 없습니다."
-
-#: src/concurrency/shared_state/arc.md:36
-msgid "`std::sync::Weak` can help."
-msgstr "순환 참조를 피하는데 `std::sync::Weak`가 도움이 될 것입니다."
-
-#: src/concurrency/shared_state/mutex.md:1
-msgid "`Mutex`"
-msgstr "`Mutex`"
-
-#: src/concurrency/shared_state/mutex.md:3
-msgid ""
-"[`Mutex<T>`](https://doc.rust-lang.org/std/sync/struct.Mutex.html) ensures "
-"mutual exclusion _and_ allows mutable access to `T` behind a read-only "
-"interface:"
-msgstr ""
-"[`Mutex<T>`](https://doc.rust-lang.org/std/sync/struct.Mutex.html)를 이용하"
-"면 불변 참조를 통해서도 `T`의 값을 수정할 수가 있으며, _이에 더해서_ 한 번에 "
-"한 스레드만 `T`의 값을 접근(읽거나 쓰거나)함을 보장해 줍니다:"
-
-#: src/concurrency/shared_state/mutex.md:6
-msgid ""
-"```rust,editable\n"
-"use std::sync::Mutex;\n"
-"\n"
-"fn main() {\n"
-"    let v = Mutex::new(vec![10, 20, 30]);\n"
-"    println!(\"v: {:?}\", v.lock().unwrap());\n"
-"\n"
-"    {\n"
-"        let mut guard = v.lock().unwrap();\n"
-"        guard.push(40);\n"
+"    // Layout according to the Linux man page for readdir(3), where ino_t "
+"and\n"
+"    // off_t are resolved according to the definitions in\n"
+"    // /usr/include/x86_64-linux-gnu/{sys/types.h, bits/typesizes.h}.\n"
+"    #[cfg(not(target_os = \"macos\"))]\n"
+"    #[repr(C)]\n"
+"    pub struct dirent {\n"
+"        pub d_ino: c_ulong,\n"
+"        pub d_off: c_long,\n"
+"        pub d_reclen: c_ushort,\n"
+"        pub d_type: c_uchar,\n"
+"        pub d_name: [c_char; 256],\n"
 "    }\n"
 "\n"
-"    println!(\"v: {:?}\", v.lock().unwrap());\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"use std::sync::Mutex;\n"
-"\n"
-"fn main() {\n"
-"    let v = Mutex::new(vec![10, 20, 30]);\n"
-"    println!(\"v: {:?}\", v.lock().unwrap());\n"
-"\n"
-"    {\n"
-"        let mut guard = v.lock().unwrap();\n"
-"        guard.push(40);\n"
+"    // Layout according to the macOS man page for dir(5).\n"
+"    #[cfg(all(target_os = \"macos\"))]\n"
+"    #[repr(C)]\n"
+"    pub struct dirent {\n"
+"        pub d_fileno: u64,\n"
+"        pub d_seekoff: u64,\n"
+"        pub d_reclen: u16,\n"
+"        pub d_namlen: u16,\n"
+"        pub d_type: u8,\n"
+"        pub d_name: [c_char; 1024],\n"
 "    }\n"
 "\n"
-"    println!(\"v: {:?}\", v.lock().unwrap());\n"
-"}\n"
-"```"
-
-#: src/concurrency/shared_state/mutex.md:22
-msgid ""
-"Notice how we have a [`impl<T: Send> Sync for Mutex<T>`](https://doc.rust-"
-"lang.org/std/sync/struct.Mutex.html#impl-Sync-for-Mutex%3CT%3E) blanket "
-"implementation."
-msgstr ""
-"모든 `Mutex<T>`는 [`impl<T: Send> Sync for Mutex<T>`](https://doc.rust-lang."
-"org/std/sync/struct.Mutex.html#impl-Sync-for-Mutex%3CT%3E)를 자동으로 구현함"
-"을 참조하세요."
-
-#: src/concurrency/shared_state/mutex.md:31
-msgid ""
-"`Mutex` in Rust looks like a collection with just one element - the "
-"protected data."
-msgstr ""
-"러스트의 `Mutex`는 오직 하나의 데이터만 담을 수 있는 컬렉션처럼 볼 수도 있습"
-"니다. 다른 컬렉션과 다른 점은, 그 데이터가 동시성 문제로부터 자유롭다는 점입"
-"니다."
-
-#: src/concurrency/shared_state/mutex.md:32
-msgid ""
-"It is not possible to forget to acquire the mutex before accessing the "
-"protected data."
-msgstr ""
-"`Mutex`는 뮤텍스를 획득하지 않으면 보호된 데이터에 접근하는 것이 불가능  하도"
-"록 디자인 되어 있습니다."
-
-#: src/concurrency/shared_state/mutex.md:33
-msgid ""
-"You can get an `&mut T` from an `&Mutex<T>` by taking the lock. The "
-"`MutexGuard` ensures that the `&mut T` doesn't outlive the lock being held."
-msgstr ""
-"`&Mutex<T>`에 대해 lock을 획득하면 `&mut T`를 얻을 수 있습니다. `MutexGuard`"
-"는 `&mut T`가 획득한 lock보다 오래 살아남지 않음을 보장합니다."
-
-#: src/concurrency/shared_state/mutex.md:35
-msgid "`Mutex<T>` implements both `Send` and `Sync` iff `T` implements `Send`."
-msgstr ""
-"`Mutex<T>`는 오직 `T`가 `Send`를 구현하는 경우에만 `Send`와 `Sync`를 구현합니"
-"다."
-
-#: src/concurrency/shared_state/mutex.md:36
-msgid "A read-write lock counterpart - `RwLock`."
-msgstr "읽기-쓰기 lock은 `RwLock`을 사용합니다."
-
-#: src/concurrency/shared_state/mutex.md:37
-msgid "Why does `lock()` return a `Result`? "
-msgstr "왜 `lock()`이 `Result`를 반환할까요?"
-
-#: src/concurrency/shared_state/mutex.md:38
-msgid ""
-"If the thread that held the `Mutex` panicked, the `Mutex` becomes "
-"\"poisoned\" to signal that the data it protected might be in an "
-"inconsistent state. Calling `lock()` on a poisoned mutex fails with a "
-"[`PoisonError`](https://doc.rust-lang.org/std/sync/struct.PoisonError.html). "
-"You can call `into_inner()` on the error to recover the data regardless."
-msgstr ""
-"`Mutex`를 획득한 스레드에서 패닉이 발생하면, 데이터가 올바르지 않은 상황이 "
-"될 수 있습니다. 이를 `Mutex`가 \"중독(poisoned)\" 되었다고 표현하며, 중독된 "
-"뮤텍스에서 `lock()`을 호출하면 실패하고 [`PoisonError`](https://doc.rust-"
-"lang.org/std/sync/struct.PoisonError.html)가 발생합니다. 이러한 오류로부터 데"
-"이터를 복구하기 위해 `into_inner()`를 호출할 수 있습니다."
-
-#: src/concurrency/shared_state/example.md:3
-msgid "Let us see `Arc` and `Mutex` in action:"
-msgstr "`Arc`와 `Mutex`의 동작을 살펴봅시다:"
-
-#: src/concurrency/shared_state/example.md:5
-msgid ""
-"```rust,editable,compile_fail\n"
-"use std::thread;\n"
-"// use std::sync::{Arc, Mutex};\n"
+"    extern \"C\" {\n"
+"        pub fn opendir(s: *const c_char) -> *mut DIR;\n"
 "\n"
-"fn main() {\n"
-"    let mut v = vec![10, 20, 30];\n"
-"    let handle = thread::spawn(|| {\n"
-"        v.push(10);\n"
-"    });\n"
-"    v.push(1000);\n"
+"        #[cfg(not(all(target_os = \"macos\", target_arch = \"x86_64\")))]\n"
+"        pub fn readdir(s: *mut DIR) -> *const dirent;\n"
 "\n"
-"    handle.join().unwrap();\n"
-"    println!(\"v: {v:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/concurrency/shared_state/example.md:23
-msgid "Possible solution:"
-msgstr "가능한 해결책:"
-
-#: src/concurrency/shared_state/example.md:25
-msgid ""
-"```rust,editable\n"
-"use std::sync::{Arc, Mutex};\n"
-"use std::thread;\n"
+"        // See https://github.com/rust-lang/libc/issues/414 and the section "
+"on\n"
+"        // _DARWIN_FEATURE_64_BIT_INODE in the macOS man page for stat(2).\n"
+"        //\n"
+"        // \"Platforms that existed before these updates were available\" "
+"refers\n"
+"        // to macOS (as opposed to iOS / wearOS / etc.) on Intel and "
+"PowerPC.\n"
+"        #[cfg(all(target_os = \"macos\", target_arch = \"x86_64\"))]\n"
+"        #[link_name = \"readdir$INODE64\"]\n"
+"        pub fn readdir(s: *mut DIR) -> *const dirent;\n"
 "\n"
-"fn main() {\n"
-"    let v = Arc::new(Mutex::new(vec![10, 20, 30]));\n"
-"\n"
-"    let v2 = v.clone();\n"
-"    let handle = thread::spawn(move || {\n"
-"        let mut v2 = v2.lock().unwrap();\n"
-"        v2.push(10);\n"
-"    });\n"
-"\n"
-"    {\n"
-"        let mut v = v.lock().unwrap();\n"
-"        v.push(1000);\n"
-"    }\n"
-"\n"
-"    handle.join().unwrap();\n"
-"\n"
-"    println!(\"v: {v:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/concurrency/shared_state/example.md:49
-msgid "Notable parts:"
-msgstr "눈여겨 볼 부분:"
-
-#: src/concurrency/shared_state/example.md:51
-msgid ""
-"`v` is wrapped in both `Arc` and `Mutex`, because their concerns are "
-"orthogonal."
-msgstr ""
-"`v`는 `Arc`와 `Mutex` 모두에 포함되어 있습니다. 이는 `Arc`와 `Mutex`가 서로 "
-"완전히 다른 문제를 위한 도구이기 때문입니다."
-
-#: src/concurrency/shared_state/example.md:52
-msgid ""
-"Wrapping a `Mutex` in an `Arc` is a common pattern to share mutable state "
-"between threads."
-msgstr ""
-"`Mutex`를 `Arc`로 래핑하는 것은 가변 상태를 스레드들 간에 공유할 때 흔히 사용"
-"하는 패턴입니다."
-
-#: src/concurrency/shared_state/example.md:53
-msgid ""
-"`v: Arc<_>` needs to be cloned as `v2` before it can be moved into another "
-"thread. Note `move` was added to the lambda signature."
-msgstr ""
-"`v: Arc<_>`를 다른 스레드에서 사용하려면, 먼저 `v2`로 복사를 하고 이를 그 스"
-"레드로 이동 해야 합니다. 그래서 람다의 시그니처에 `move`가 있는 것입니다."
-
-#: src/concurrency/shared_state/example.md:54
-msgid ""
-"Blocks are introduced to narrow the scope of the `LockGuard` as much as "
-"possible."
-msgstr "블록은 `LockGuard`의 범위를 최대한 좁히기 위해 사용되었습니다."
-
-#: src/concurrency/send-sync.md:1
-msgid "`Send` and `Sync`"
-msgstr "`Send`와 `Sync`"
-
-#: src/concurrency/send-sync.md:3
-msgid ""
-"How does Rust know to forbid shared access across thread? The answer is in "
-"two traits:"
-msgstr ""
-"러스트는 어떻게 해서 스레드 간에 특정 데이터 타입이 공유될 수 있거나, 안된다"
-"는 것을 알까요? 정답은 다음 두 트레잇에 있습니다:"
-
-#: src/concurrency/send-sync.md:5
-msgid ""
-"[`Send`](https://doc.rust-lang.org/std/marker/trait.Send.html): a type `T` "
-"is `Send` if it is safe to move a `T` across a thread boundary."
-msgstr ""
-"[`Send`](https://doc.rust-lang.org/std/marker/trait.Send.html): `T`가 스레드 "
-"간 이동이 안전하다면, `T`의 타입은 `Send`입니다."
-
-#: src/concurrency/send-sync.md:7
-msgid ""
-"[`Sync`](https://doc.rust-lang.org/std/marker/trait.Sync.html): a type `T` "
-"is `Sync` if it is safe to move a `&T` across a thread boundary."
-msgstr ""
-"[`Sync`](https://doc.rust-lang.org/std/marker/trait.Sync.html): `&T`가 스레"
-"드 간 이동이 안전하다면, `&T`의 타입은 `Sync`입니다."
-
-#: src/concurrency/send-sync.md:10
-msgid ""
-"`Send` and `Sync` are [unsafe traits](../unsafe/unsafe-traits.md). The "
-"compiler will automatically derive them for your types as long as they only "
-"contain `Send` and `Sync` types. You can also implement them manually when "
-"you know it is valid."
-msgstr ""
-"`Send`와 `Sync` 트레잇은 [안전하지 않은 트레잇](../unsafe/unsafe-traits.md)입"
-"니다. 컴파일러는 타입의 요소들이 모두 `Send`와 `Sync` 타입이면 자동으로 이 트"
-"레잇들을 적용시켜 줍니다. 물론 여러분 스스로 맞다고 알고 있다면 직접 구현해"
-"도 됩니다."
-
-#: src/concurrency/send-sync.md:20
-msgid ""
-"One can think of these traits as markers that the type has certain thread-"
-"safety properties."
-msgstr ""
-"`Sync`와 `Send`는 어떤 타입이 특정한 스레드-안전 속성을 가짐을 나타내는 마커"
-"로 생각할 수 있습니다."
-
-#: src/concurrency/send-sync.md:21
-msgid "They can be used in the generic constraints as normal traits."
-msgstr ""
-"이 두 트레이트는 제너릭에서 제약 조건을 나타내는 트레이트로 사용될 수도 있습"
-"니다."
-
-#: src/concurrency/send-sync/send.md:1
-msgid "`Send`"
-msgstr "`Send`"
-
-#: src/concurrency/send-sync/send.md:3
-msgid ""
-"A type `T` is [`Send`](https://doc.rust-lang.org/std/marker/trait.Send.html) "
-"if it is safe to move a `T` value to another thread."
-msgstr ""
-"`T`가 스레드 간에 안전하게 이동될 수 있다면, `T`의 타입은 `Send`입니다."
-
-#: src/concurrency/send-sync/send.md:5
-msgid ""
-"The effect of moving ownership to another thread is that _destructors_ will "
-"run in that thread. So the question is when you can allocate a value in one "
-"thread and deallocate it in another."
-msgstr ""
-"소유권을 다른 스레드로 이동하면 소멸자가 해당 스레드에서 실행됩니다. 여기서 "
-"의문은 \"언제 한 스레드에서 값을 할당하고 다른 스레드에서 값을 할당 해제할 "
-"수 있는가\" 입니다."
-
-#: src/concurrency/send-sync/sync.md:1
-msgid "`Sync`"
-msgstr "`Sync`"
-
-#: src/concurrency/send-sync/sync.md:3
-msgid ""
-"A type `T` is [`Sync`](https://doc.rust-lang.org/std/marker/trait.Sync.html) "
-"if it is safe to access a `T` value from multiple threads at the same time."
-msgstr ""
-"`&T`가 여러 스레드에서 안전하게 접근될 수 있다면, `&T`의 타입은 `Sync`입니다."
-
-#: src/concurrency/send-sync/sync.md:6
-msgid "More precisely, the definition is:"
-msgstr "좀 더 정확한 정의는 다음과 같습니다:"
-
-#: src/concurrency/send-sync/sync.md:8
-msgid "`T` is `Sync` if and only if `&T` is `Send`"
-msgstr "`&T`가 `Send`인 경우에만 `T`의 타입이 `Sync`가 됩니다"
-
-#: src/concurrency/send-sync/sync.md:14
-msgid ""
-"This statement is essentially a shorthand way of saying that if a type is "
-"thread-safe for shared use, it is also thread-safe to pass references of it "
-"across threads."
-msgstr ""
-"위 문장을 풀어서 이야기 하면, 어떤 타입이 스레드 간에 공유되어서 사용되기에 "
-"안전하다면 그 타입의 참조 타입은 스레드 간에 이동 가능하다는 것입니다."
-
-#: src/concurrency/send-sync/sync.md:16
-msgid ""
-"This is because if a type is Sync it means that it can be shared across "
-"multiple threads without the risk of data races or other synchronization "
-"issues, so it is safe to move it to another thread. A reference to the type "
-"is also safe to move to another thread, because the data it references can "
-"be accessed from any thread safely."
-msgstr ""
-"이는 다음과 같이 증명할 수 있습니다: 어떤 타입이 `Sync`라는 말은 곧 그 타입"
-"이 여러 스레드들 사이에서 데이터 레이스나 여타 동기화 문제 없이 공유 가능하다"
-"는 말입니다. 스레드 간 공유가 안전하다면, 스레드간 이동도 안전할 수 밖에 없습"
-"니다. 어떤 타입의 스레드간 이동이 안전하다면, 그 타입의 참조 또한 스레드간 이"
-"동이 안전할 수 밖에 없습니다."
-
-#: src/concurrency/send-sync/examples.md:3
-msgid "`Send + Sync`"
-msgstr "`Send + Sync`"
-
-#: src/concurrency/send-sync/examples.md:5
-msgid "Most types you come across are `Send + Sync`:"
-msgstr "여러분이 다루게 될 대부분의 타입은 `Send + Sync`입니다:"
-
-#: src/concurrency/send-sync/examples.md:7
-msgid "`i8`, `f32`, `bool`, `char`, `&str`, ..."
-msgstr "`i8`, `f32`, `bool`, `char`, `&str`, ..."
-
-#: src/concurrency/send-sync/examples.md:8
-msgid "`(T1, T2)`, `[T; N]`, `&[T]`, `struct { x: T }`, ..."
-msgstr "`(T1, T2)`, `[T; N]`, `&[T]`, `struct { x: T }`, ..."
-
-#: src/concurrency/send-sync/examples.md:9
-msgid "`String`, `Option<T>`, `Vec<T>`, `Box<T>`, ..."
-msgstr "`String`, `Option<T>`, `Vec<T>`, `Box<T>`, ..."
-
-#: src/concurrency/send-sync/examples.md:10
-msgid "`Arc<T>`: Explicitly thread-safe via atomic reference count."
-msgstr "`Arc<T>`: 참조 카운트 조작을 아토믹 하기 때문에 스레드 안전함."
-
-#: src/concurrency/send-sync/examples.md:11
-msgid "`Mutex<T>`: Explicitly thread-safe via internal locking."
-msgstr ""
-"`Mutex<T>`: 값을 접근하기 위해 뮤택스를 잠궈야 하기 때문에 스레드 안전함."
-
-#: src/concurrency/send-sync/examples.md:12
-msgid "`AtomicBool`, `AtomicU8`, ...: Uses special atomic instructions."
-msgstr ""
-"`AtomicBool`, `AtomicU8`, ...: 값을 접근할 때 특별한 아토믹 명령어들을 사용합"
-"니다."
-
-#: src/concurrency/send-sync/examples.md:14
-msgid ""
-"The generic types are typically `Send + Sync` when the type parameters are "
-"`Send + Sync`."
-msgstr ""
-"제네릭 타입은 일반적으로 타입 파라메터가 `Send + Sync`이면 `Send + Sync` 입니"
-"다."
-
-#: src/concurrency/send-sync/examples.md:17
-msgid "`Send + !Sync`"
-msgstr "`Send + !Sync`"
-
-#: src/concurrency/send-sync/examples.md:19
-msgid ""
-"These types can be moved to other threads, but they're not thread-safe. "
-"Typically because of interior mutability:"
-msgstr ""
-"아래 타입들은 다른 스레드로 이동될 수 있지만 내부적으로 값이 변경될 수 있기 "
-"때문에 스레드 안전하지 않습니다:"
-
-#: src/concurrency/send-sync/examples.md:22
-msgid "`mpsc::Sender<T>`"
-msgstr "`mpsc::Sender<T>`"
-
-#: src/concurrency/send-sync/examples.md:23
-msgid "`mpsc::Receiver<T>`"
-msgstr "`mpsc::Receiver<T>`"
-
-#: src/concurrency/send-sync/examples.md:24
-msgid "`Cell<T>`"
-msgstr "`Cell<T>`"
-
-#: src/concurrency/send-sync/examples.md:25
-msgid "`RefCell<T>`"
-msgstr "`RefCell<T>`"
-
-#: src/concurrency/send-sync/examples.md:27
-msgid "`!Send + Sync`"
-msgstr "`!Send + Sync`"
-
-#: src/concurrency/send-sync/examples.md:29
-msgid ""
-"These types are thread-safe, but they cannot be moved to another thread:"
-msgstr "아래 타입들은 스레드 안전하지만 다른 스레드로 이동될 수 없습니다:"
-
-#: src/concurrency/send-sync/examples.md:31
-msgid ""
-"`MutexGuard<T>`: Uses OS level primitives which must be deallocated on the "
-"thread which created them."
-msgstr ""
-"`MutexGuard<T>`: 내부적으로, 운영체제가 제공하는 primitive를 사용하는데, 이 "
-"primitive는 생성된 스레드에서 해제가 이루어져야 합니다. (_역주_: 그래서 다른 "
-"스레드로 옮길 수 없습니다.)"
-
-#: src/concurrency/send-sync/examples.md:34
-msgid "`!Send + !Sync`"
-msgstr "`!Send + !Sync`"
-
-#: src/concurrency/send-sync/examples.md:36
-msgid "These types are not thread-safe and cannot be moved to other threads:"
-msgstr ""
-"아래 타입들은 스레드 안전하지도 않고 다른 스레드로 이동될 수도 없습니다:"
-
-#: src/concurrency/send-sync/examples.md:38
-msgid ""
-"`Rc<T>`: each `Rc<T>` has a reference to an `RcBox<T>`, which contains a non-"
-"atomic reference count."
-msgstr ""
-"`Rc<T>`: `Rc<T>` 는 아토믹하지 않은 방식으로 참조 카운트를 조작하는 "
-"`RcBox<T>`를 참조합니다."
-
-#: src/concurrency/send-sync/examples.md:40
-msgid ""
-"`*const T`, `*mut T`: Rust assumes raw pointers may have special concurrency "
-"considerations."
-msgstr ""
-"`*const T`, `*mut T`: 러스트는 포인터가 스레드 안전하지 않다고 가정합니다."
-
-#: src/concurrency/send-sync/send.md:13
-msgid ""
-"As an example, a connection to the SQLite library must only be accessed from "
-"a single thread."
-msgstr ""
-"예를 들어 SQLite 라이브러리 연결은 단일 스레드에서만 액세스해야 합니다."
-
-#: src/concurrency/shared_state/arc.md:5
-msgid ""
-"```rust,editable\n"
-"use std::thread;\n"
-"use std::sync::Arc;\n"
-"\n"
-"fn main() {\n"
-"    let v = Arc::new(vec![10, 20, 30]);\n"
-"    let mut handles = Vec::new();\n"
-"    for _ in 1..5 {\n"
-"        let v = Arc::clone(&v);\n"
-"        handles.push(thread::spawn(move || {\n"
-"            let thread_id = thread::current().id();\n"
-"            println!(\"{thread_id:?}: {v:?}\");\n"
-"        }));\n"
-"    }\n"
-"\n"
-"    handles.into_iter().for_each(|h| h.join().unwrap());\n"
-"    println!(\"v: {v:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"use std::thread;\n"
-"use std::sync::Arc;\n"
-"\n"
-"fn main() {\n"
-"    let v = Arc::new(vec![10, 20, 30]);\n"
-"    let mut handles = Vec::new();\n"
-"    for _ in 1..5 {\n"
-"        let v = Arc::clone(&v);\n"
-"        handles.push(thread::spawn(move || {\n"
-"            let thread_id = thread::current().id();\n"
-"            println!(\"{thread_id:?}: {v:?}\");\n"
-"        }));\n"
-"    }\n"
-"\n"
-"    handles.into_iter().for_each(|h| h.join().unwrap());\n"
-"    println!(\"v: {v:?}\");\n"
-"}\n"
-"```"
-
-#: src/concurrency/shared_state/example.md:25
-msgid ""
-"```rust,editable\n"
-"use std::sync::{Arc, Mutex};\n"
-"use std::thread;\n"
-"\n"
-"fn main() {\n"
-"    let v = Arc::new(Mutex::new(vec![10, 20, 30]));\n"
-"\n"
-"    let v2 = Arc::clone(&v);\n"
-"    let handle = thread::spawn(move || {\n"
-"        let mut v2 = v2.lock().unwrap();\n"
-"        v2.push(10);\n"
-"    });\n"
-"\n"
-"    {\n"
-"        let mut v = v.lock().unwrap();\n"
-"        v.push(1000);\n"
-"    }\n"
-"\n"
-"    handle.join().unwrap();\n"
-"\n"
-"    println!(\"v: {v:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"use std::sync::{Arc, Mutex};\n"
-"use std::thread;\n"
-"\n"
-"fn main() {\n"
-"    let v = Arc::new(Mutex::new(vec![10, 20, 30]));\n"
-"\n"
-"    let v2 = Arc::clone(&v);\n"
-"    let handle = thread::spawn(move || {\n"
-"        let mut v2 = v2.lock().unwrap();\n"
-"        v2.push(10);\n"
-"    });\n"
-"\n"
-"    {\n"
-"        let mut v = v.lock().unwrap();\n"
-"        v.push(1000);\n"
-"    }\n"
-"\n"
-"    handle.join().unwrap();\n"
-"\n"
-"    println!(\"v: {v:?}\");\n"
-"}\n"
-"```"
-
-#: src/async.md:3
-msgid ""
-"\"Async\" is a concurrency model where multiple tasks are executed "
-"concurrently by executing each task until it would block, then switching to "
-"another task that is ready to make progress. The model allows running a "
-"larger number of tasks on a limited number of threads. This is because the "
-"per-task overhead is typically very low and operating systems provide "
-"primitives for efficiently identifying I/O that is able to proceed."
-msgstr ""
-"\"Async\"는 블럭될(더 이상 진행할 수 없을) 때까지 각 작업을 실행한 다음 진행"
-"할 준비가 된 다른 작업으로 전환하여 여러 작업을 동시에 실행하는 동시 실행 모"
-"델입니다. 이 모델을 사용하면 제한된 수의 스레드에서 더 많은 작업을 실행할 수 "
-"있습니다. 이는, 한 작업을 유지하고 수행하는데 필요한 오버헤드가 (스레드에 비"
-"해) 매우 낮고 운영체제가 여러 I/O들에서 현재 진행 가능한 I/O들을 효과적으로 "
-"식별해 주는 프리미티브를 제공하기 때문입니다."
-
-#: src/async.md:10
-msgid ""
-"Rust's asynchronous operation is based on \"futures\", which represent work "
-"that may be completed in the future. Futures are \"polled\" until they "
-"signal that they are complete."
-msgstr ""
-"Rust의 비동기 작업은 \"futures\"를 기반으로 하며 이는 미래에 완료될 수 있는 "
-"작업을 나타냅니다. Futures는 완료되었다는 신호를 보낼 때까지 \"폴링\"됩니다."
-
-#: src/async.md:14
-msgid ""
-"Futures are polled by an async runtime, and several different runtimes are "
-"available."
-msgstr ""
-"Futures는 비동기 런타임에 의해 폴링되며, 비동기 런타임에는 여러 다양한 종류"
-"가 있습니다."
-
-#: src/async.md:19
-msgid ""
-"Python has a similar model in its `asyncio`. However, its `Future` type is "
-"callback-based, and not polled. Async Python programs require a \"loop\", "
-"similar to a runtime in Rust."
-msgstr ""
-"파이썬에도 `asyncio`라는 유사한 모델이 있습니다. 그러나 파이썬의 `Future` 타"
-"입은 콜백 기반이며 폴링되지 않습니다. 파이썬으로 비동기 프로그래밍을 할 때에"
-"는, Rust에서 런타임이 내부적으로 해 주는 것과 유사한,  \"루프\"를 명시적으로 "
-"사용해야 합니다."
-
-#: src/async.md:23
-msgid ""
-"JavaScript's `Promise` is similar, but again callback-based. The language "
-"runtime implements the event loop, so many of the details of Promise "
-"resolution are hidden."
-msgstr ""
-"자바스크립트의 `Promise`도 비슷하지만 역시 콜백 기반입니다. 자바스크립트에서"
-"는 이벤트 루프가런타임 엔진에서 구현되므로 `Promise`가 처리되는 세부 과정이 "
-"숨겨집니다."
-
-#: src/async/async-await.md:1
-msgid "`async`/`await`"
-msgstr "`async`/`await`"
-
-#: src/async/async-await.md:3
-msgid ""
-"At a high level, async Rust code looks very much like \"normal\" sequential "
-"code:"
-msgstr ""
-"겉에서 보았을 때, 비동기 Rust 코드는 일반적인 절차적 코드와 매우 유사합니다."
-
-#: src/async/async-await.md:5
-msgid ""
-"```rust,editable,compile_fail\n"
-"use futures::executor::block_on;\n"
-"\n"
-"async fn count_to(count: i32) {\n"
-"    for i in 1..=count {\n"
-"        println!(\"Count is: {i}!\");\n"
+"        pub fn closedir(s: *mut DIR) -> c_int;\n"
 "    }\n"
 "}\n"
 "\n"
-"async fn async_main(count: i32) {\n"
-"    count_to(count).await;\n"
-"}\n"
+"use std::ffi::{CStr, CString, OsStr, OsString};\n"
+"use std::os::unix::ffi::OsStrExt;\n"
 "\n"
-"fn main() {\n"
-"    block_on(async_main(10));\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use futures::executor::block_on;\n"
-"\n"
-"async fn count_to(count: i32) {\n"
-"    for i in 1..=count {\n"
-"        println!(\"Count is: {i}!\");\n"
-"    }\n"
-"}\n"
-"\n"
-"async fn async_main(count: i32) {\n"
-"    count_to(count).await;\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    block_on(async_main(10));\n"
-"}\n"
-"```"
-
-#: src/async/async-await.md:27
-msgid ""
-"Note that this is a simplified example to show the syntax. There is no long "
-"running operation or any real concurrency in it!"
-msgstr ""
-"Rust 비동기 문법을 보여주는 간단한 예시입니다. 여기에는 오래 실행되는 작업이"
-"나, 실제로 동시에 수행되는 것들은 없습니다."
-
-#: src/async/async-await.md:30
-msgid "What is the return type of an async call?"
-msgstr "`async`함수의 리턴 타입은 무엇인가요?"
-
-#: src/async/async-await.md:31
-msgid "Use `let future: () = async_main(10);` in `main` to see the type."
-msgstr ""
-"`main`에서 \\`let future: () = async_main(10);을 사용하여 타입을 확인하세요."
-
-#: src/async/async-await.md:33
-msgid ""
-"The \"async\" keyword is syntactic sugar. The compiler replaces the return "
-"type with a future. "
-msgstr ""
-"\"async\" 키워드는 문법 설탕(syntactic sugar)입니다. 컴파일러가 리턴 타입을 "
-"future로 바꿉니다. "
-
-#: src/async/async-await.md:36
-msgid ""
-"You cannot make `main` async, without additional instructions to the "
-"compiler on how to use the returned future."
-msgstr ""
-"`main`을 비동기 함수로 만들수는 없습니다. 만약 그렇게 할 경우 컴파일러는 리"
-"턴 타입인 future를 어떻게 사용할 지 모르기 때문입니다."
-
-#: src/async/async-await.md:39
-msgid ""
-"You need an executor to run async code. `block_on` blocks the current thread "
-"until the provided future has run to completion. "
-msgstr ""
-"비동기 코드를 실행하려면 실행자(executor)가 필요합니다. `block_on` 실행자는 "
-"제공된 future가 완료될 때까지 현재 스레드를 블록합니다. "
-
-#: src/async/async-await.md:42
-msgid ""
-"`.await` asynchronously waits for the completion of another operation. "
-"Unlike `block_on`, `.await` doesn't block the current thread."
-msgstr ""
-"`.await`는 다른 작업이 완료될 때까지 비동기적으로 대기합니다. `block_on`과 달"
-"리 `.await`는 현재 스레드를 블록하지 않습니다."
-
-#: src/async/async-await.md:45
-msgid ""
-"`.await` can only be used inside an `async` function (or block; these are "
-"introduced later). "
-msgstr ""
-"`.await`는 `async` 함수(또는 나중에 소개될 `async` 블록) 안에서만 사용할 수 "
-"있습니다. "
-
-#: src/async/futures.md:3
-msgid ""
-"[`Future`](https://doc.rust-lang.org/std/future/trait.Future.html) is a "
-"trait, implemented by objects that represent an operation that may not be "
-"complete yet. A future can be polled, and `poll` returns a [`Poll`](https://"
-"doc.rust-lang.org/std/task/enum.Poll.html)."
-msgstr ""
-"[`Future`](https://doc.rust-lang.org/std/future/trait.Future.html)는 트레잇입"
-"니다.이 트레잇은 아직 완료되지 않았을 수도 있는 작업을 나타냅니다. Future는 "
-"`poll` 함수를 통해 폴링될 수 있으며, 이 함수는 [`Poll`](https://doc.rust-"
-"lang.org/std/task/enum.Poll.html)을 반환합니다."
-
-#: src/async/futures.md:8
-msgid ""
-"```rust\n"
-"use std::pin::Pin;\n"
-"use std::task::Context;\n"
-"\n"
-"pub trait Future {\n"
-"    type Output;\n"
-"    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::"
-"Output>;\n"
-"}\n"
-"\n"
-"pub enum Poll<T> {\n"
-"    Ready(T),\n"
-"    Pending,\n"
-"}\n"
-"```"
-msgstr ""
-"```rust\n"
-"use std::pin::Pin;\n"
-"use std::task::Context;\n"
-"\n"
-"pub trait Future {\n"
-"    type Output;\n"
-"    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::"
-"Output>;\n"
-"}\n"
-"\n"
-"pub enum Poll<T> {\n"
-"    Ready(T),\n"
-"    Pending,\n"
-"}\n"
-"```"
-
-#: src/async/futures.md:23
-msgid ""
-"An async function returns an `impl Future`. It's also possible (but "
-"uncommon) to implement `Future` for your own types. For example, the "
-"`JoinHandle` returned from `tokio::spawn` implements `Future` to allow "
-"joining to it."
-msgstr ""
-"비동기 함수는 `impl Future`를 반환합니다. 새로운 타입을 만들고 이 타입이 "
-"`Future`를 구현하게 할 수도 있지만 일반적이지는 않습니다. 예를 들어 `tokio::"
-"spawn`가 리턴하는 `JoinHandle`은 `Future`를 구현하며, 이를 통해 생성된 스레드"
-"에 join할 수 있습니다."
-
-#: src/async/futures.md:27
-msgid ""
-"The `.await` keyword, applied to a Future, causes the current async function "
-"to pause until that Future is ready, and then evaluates to its output."
-msgstr ""
-"Future에 `.await`를 호출하면, 해당 Future가 준비될 때까지 현재 비동기 함수가 "
-"일시 중지됩니다. 그런 다음 Future가 준비가 되면, 그 값이 `.await` 구문의 값"
-"이 됩니다."
-
-#: src/async/futures.md:32
-msgid ""
-"The `Future` and `Poll` types are implemented exactly as shown; click the "
-"links to show the implementations in the docs."
-msgstr ""
-"`Future` 와 `Poll` 타입의 실제 정의는 위에 보이는 그대로 입니다. 링크를 클릭"
-"하면 Rust 문서에서 한 번 더 확인할 수 있습니다."
-
-#: src/async/futures.md:35
-msgid ""
-"We will not get to `Pin` and `Context`, as we will focus on writing async "
-"code, rather than building new async primitives. Briefly:"
-msgstr ""
-"본 강의의 목적은 비동기 코드를 작성하는데 있기 때문에, 새로운 비동기 프리미티"
-"브를 만드는데 필요한  `Pin`과 `Context`는 다루지 않습니다. 이들에 대해 간단"
-"히 설명하자면:"
-
-#: src/async/futures.md:38
-msgid ""
-"`Context` allows a Future to schedule itself to be polled again when an "
-"event occurs."
-msgstr ""
-"`Context`를 사용하면 Future가 이벤트가 발생할 때 다시 폴링되도록 예약할 수 있"
-"습니다."
-
-#: src/async/futures.md:41
-msgid ""
-"`Pin` ensures that the Future isn't moved in memory, so that pointers into "
-"that future remain valid. This is required to allow references to remain "
-"valid after an `.await`."
-msgstr ""
-"'Pin'을 사용하면 메모리에서 Future의 위치가 고정되기 때문에 해당 future의 포"
-"인터가 항상 유효하게 유지됩니다. 이는 `.await` 후에 참조를 유효한 상태로 유지"
-"하기 위해 필요합니다."
-
-#: src/async/runtimes.md:3
-msgid ""
-"A _runtime_ provides support for performing operations asynchronously (a "
-"_reactor_) and is responsible for executing futures (an _executor_). Rust "
-"does not have a \"built-in\" runtime, but several options are available:"
-msgstr ""
-"비동기 _런타임_은 _리액터_ (비동기식 작업 실행을 지원)와 _실행자_ (futures를 "
-"실행)의 두 가지 역할을 합니다. Rust 언어 자체에서 기본 제공하는 비동기 런타임"
-"은 없습니다. 그러나 다음과 같은 비동기 런타임 크레잇들이 있습니다."
-
-#: src/async/runtimes.md:7
-msgid ""
-"[Tokio](https://tokio.rs/) - performant, with a well-developed ecosystem of "
-"functionality like [Hyper](https://hyper.rs/) for HTTP or [Tonic](https://"
-"github.com/hyperium/tonic) for gRPC."
-msgstr ""
-"[Tokio](https://tokio.rs/) - 성능이 우수합니다. 그리고 HTTP를 지원하는 "
-"[Hyper](https://hyper.rs/) 와 gRPC를 지원하는 [Tonic](https://github.com/"
-"hyperium/tonic)과 같은 잘 발달된 라이브러리 생태계가 있습니다."
-
-#: src/async/runtimes.md:10
-msgid ""
-"[async-std](https://async.rs/) - aims to be a \"std for async\", and "
-"includes a basic runtime in `async::task`."
-msgstr ""
-"[async-std](https://async.rs/) - 비동기에서의 `std`를 목표로 하고 있습니다. "
-"`async::task`에 기본 런타임이 포함되어 있습니다."
-
-#: src/async/runtimes.md:12
-msgid "[smol](https://docs.rs/smol/latest/smol/) - simple and lightweight"
-msgstr "[smol](https://docs.rs/smol/latest/smol/) - 간단하고 가볍습니다."
-
-#: src/async/runtimes.md:14
-msgid ""
-"Several larger applications have their own runtimes. For example, [Fuchsia]"
-"(https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/src/lib/fuchsia-"
-"async/src/lib.rs) already has one."
-msgstr ""
-"여러 대규모 애플리케이션에는 자체 런타임이 있는 경우도 있습니다. 예들 들어  "
-"[Fuchsia](https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/src/lib/"
-"fuchsia-async/src/lib.rs)가 있습니다."
-
-#: src/async/runtimes.md:20
-msgid ""
-"Note that of the listed runtimes, only Tokio is supported in the Rust "
-"playground. The playground also does not permit any I/O, so most interesting "
-"async things can't run in the playground."
-msgstr ""
-"Rust 플레이그라운드에서는 위에 나열된 비동기 런타임 중에서 Tokio만 사용할 수 "
-"있습니다. 또한 Rust 플레이그라운드는 I/O를 허용하지 않으므로 async를 가지고 "
-"할 수 있는 많은 흥미로운 작업들이 불가능 합니다."
-
-#: src/async/runtimes.md:24
-msgid ""
-"Futures are \"inert\" in that they do not do anything (not even start an I/O "
-"operation) unless there is an executor polling them. This differs from JS "
-"Promises, for example, which will run to completion even if they are never "
-"used."
-msgstr ""
-"Futures는 실행자가 폴링하지 않는 한 아무것도 하지 않는다는 점에서(I/O 작업조"
-"차 시작하지 않음) \"비활성\" 상태입니다. 이는 사용되지 않는 경우에도 완료될 "
-"때 까지 실행되는, 자바 스크립트의 promise와 다릅니다."
-
-#: src/async/runtimes/tokio.md:1 src/SUMMARY.md:283
-msgid "Tokio"
-msgstr "Tokio"
-
-#: src/async/runtimes/tokio.md:4
-msgid "Tokio provides: "
-msgstr "Tokio는 다음을 제공합니다. "
-
-#: src/async/runtimes/tokio.md:6
-msgid "A multi-threaded runtime for executing asynchronous code."
-msgstr "비동기 코드 실행을 위한 멀티스레드 런타임"
-
-#: src/async/runtimes/tokio.md:7
-msgid "An asynchronous version of the standard library."
-msgstr "표준 라이브러리의 비동기 버전"
-
-#: src/async/runtimes/tokio.md:8
-msgid "A large ecosystem of libraries."
-msgstr "대규모 라이브러리 생태계"
-
-#: src/async/runtimes/tokio.md:10
-msgid ""
-"```rust,editable,compile_fail\n"
-"use tokio::time;\n"
-"\n"
-"async fn count_to(count: i32) {\n"
-"    for i in 1..=count {\n"
-"        println!(\"Count in task: {i}!\");\n"
-"        time::sleep(time::Duration::from_millis(5)).await;\n"
-"    }\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    tokio::spawn(count_to(10));\n"
-"\n"
-"    for i in 1..5 {\n"
-"        println!(\"Main task: {i}\");\n"
-"        time::sleep(time::Duration::from_millis(5)).await;\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use tokio::time;\n"
-"\n"
-"async fn count_to(count: i32) {\n"
-"    for i in 1..=count {\n"
-"        println!(\"Count in task: {i}!\");\n"
-"        time::sleep(time::Duration::from_millis(5)).await;\n"
-"    }\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    tokio::spawn(count_to(10));\n"
-"\n"
-"    for i in 1..5 {\n"
-"        println!(\"Main task: {i}\");\n"
-"        time::sleep(time::Duration::from_millis(5)).await;\n"
-"    }\n"
-"}\n"
-"```"
-
-#: src/async/runtimes/tokio.md:33
-msgid "With the `tokio::main` macro we can now make `main` async."
-msgstr ""
-"이제 `tokio::main` 매크로를 사용하면 `main`을 비동기로 만들 수 있습니다."
-
-#: src/async/runtimes/tokio.md:35
-msgid "The `spawn` function creates a new, concurrent \"task\"."
-msgstr "`spawn` 함수는 동시 실행되는 새로운 \"작업\"을 만듭니다."
-
-#: src/async/runtimes/tokio.md:37
-msgid "Note: `spawn` takes a `Future`, you don't call `.await` on `count_to`."
-msgstr ""
-"참고: `spawn`은 `Future`를 인자로 받습니다. 때문에 `count_to`에 `.await`를 호"
-"출하지 않는 점을 주목하세요."
-
-#: src/async/runtimes/tokio.md:39
-msgid "**Further exploration:**"
-msgstr "**심화 학습:**"
-
-#: src/async/runtimes/tokio.md:41
-msgid ""
-"Why does `count_to` not (usually) get to 10? This is an example of async "
-"cancellation. `tokio::spawn` returns a handle which can be awaited to wait "
-"until it finishes."
-msgstr ""
-"`count_to`가 10에 도달하지 않는 경우가 많은데 그 이유는 무엇일까요? 이는 비동"
-"기적인 취소를 보여주는 예입니다. `tokio::spawn`이 리턴하는 것은 완료될 때까"
-"지 기다리도록 대기하는데 사용되는 핸들입니다."
-
-#: src/async/runtimes/tokio.md:45
-msgid "Try `count_to(10).await` instead of spawning."
-msgstr "`tokio::spawn` 대신 `count_to(10).await`를 사용해 보세요."
-
-#: src/async/runtimes/tokio.md:47
-msgid "Try awaiting the task returned from `tokio::spawn`."
-msgstr "`tokio::spawn`에서 반환된 작업을 `await` 해 보세요."
-
-#: src/async/tasks.md:3
-msgid "Rust has a task system, which is a form of lightweight threading."
-msgstr "Rust의 태스크(작업) 시스템은 경량 스레딩의 한 종류로 볼 수 있습니다."
-
-#: src/async/tasks.md:5
-msgid ""
-"A task has a single top-level future which the executor polls to make "
-"progress. That future may have one or more nested futures that its `poll` "
-"method polls, corresponding loosely to a call stack. Concurrency within a "
-"task is possible by polling multiple child futures, such as racing a timer "
-"and an I/O operation."
-msgstr ""
-"하나의 작업에는, 실행자가 이 작업을 진행하기 위해 계속 폴링하는, 최상위 "
-"future가 한 개 있습니다. 이 future에는 `poll` 메서드가 폴링하는 중첩된 future"
-"가 한 개 이상 있을 수 있습니다. 이러한 중첩된 future는 일반적인 함수 호출 스"
-"택하고 비슷한 역할을 합니다. 한 작업 안에서 여러 자식 future들을 폴링하면, 타"
-"이머를 켜는 것과 어떤 I/O작업을 동시에 수행시킨 후 타이머와 I/O 중 먼저 끝나"
-"는 것을 기다리는 것과 같은동시성도 구현할 수 있습니다."
-
-#: src/async/tasks.md:10
-msgid ""
-"```rust,compile_fail\n"
-"use tokio::io::{self, AsyncReadExt, AsyncWriteExt};\n"
-"use tokio::net::TcpListener;\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() -> io::Result<()> {\n"
-"    let listener = TcpListener::bind(\"127.0.0.1:6142\").await?;\n"
-"\tprintln!(\"listening on port 6142\");\n"
-"\n"
-"    loop {\n"
-"        let (mut socket, addr) = listener.accept().await?;\n"
-"\n"
-"        println!(\"connection from {addr:?}\");\n"
-"\n"
-"        tokio::spawn(async move {\n"
-"            if let Err(e) = socket.write_all(b\"Who are you?\\n\").await {\n"
-"                println!(\"socket error: {e:?}\");\n"
-"                return;\n"
-"            }\n"
-"\n"
-"            let mut buf = vec![0; 1024];\n"
-"            let reply = match socket.read(&mut buf).await {\n"
-"                Ok(n) => {\n"
-"                    let name = std::str::from_utf8(&buf[..n]).unwrap()."
-"trim();\n"
-"                    format!(\"Thanks for dialing in, {name}!\\n\")\n"
-"                }\n"
-"                Err(e) => {\n"
-"                    println!(\"socket error: {e:?}\");\n"
-"                    return;\n"
-"                }\n"
-"            };\n"
-"\n"
-"            if let Err(e) = socket.write_all(reply.as_bytes()).await {\n"
-"                println!(\"socket error: {e:?}\");\n"
-"            }\n"
-"        });\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,compile_fail\n"
-"use tokio::io::{self, AsyncReadExt, AsyncWriteExt};\n"
-"use tokio::net::TcpListener;\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() -> io::Result<()> {\n"
-"    let listener = TcpListener::bind(\"127.0.0.1:6142\").await?;\n"
-"\tprintln!(\"listening on port 6142\");\n"
-"\n"
-"    loop {\n"
-"        let (mut socket, addr) = listener.accept().await?;\n"
-"\n"
-"        println!(\"connection from {addr:?}\");\n"
-"\n"
-"        tokio::spawn(async move {\n"
-"            if let Err(e) = socket.write_all(b\"Who are you?\\n\").await {\n"
-"                println!(\"socket error: {e:?}\");\n"
-"                return;\n"
-"            }\n"
-"\n"
-"            let mut buf = vec![0; 1024];\n"
-"            let reply = match socket.read(&mut buf).await {\n"
-"                Ok(n) => {\n"
-"                    let name = std::str::from_utf8(&buf[..n]).unwrap()."
-"trim();\n"
-"                    format!(\"Thanks for dialing in, {name}!\\n\")\n"
-"                }\n"
-"                Err(e) => {\n"
-"                    println!(\"socket error: {e:?}\");\n"
-"                    return;\n"
-"                }\n"
-"            };\n"
-"\n"
-"            if let Err(e) = socket.write_all(reply.as_bytes()).await {\n"
-"                println!(\"socket error: {e:?}\");\n"
-"            }\n"
-"        });\n"
-"    }\n"
-"}\n"
-"```"
-
-#: src/async/tasks.md:52 src/async/control-flow/join.md:36
-msgid ""
-"Copy this example into your prepared `src/main.rs` and run it from there."
-msgstr ""
-"이 예제를, 로컬 컴퓨터에 만들어 둔 `src/main.rs`에 복사하고 거기에서 실행하세"
-"요."
-
-#: src/async/tasks.md:54
-msgid ""
-"Ask students to visualize what the state of the example server would be with "
-"a few connected clients. What tasks exist? What are their Futures?"
-msgstr ""
-"수강생들에게 이 서버에 몇 개의 클라이언트가 연결되면 이 서버의 상태가 어떻게 "
-"변할지 그림을 그려보도록 하세요. 어떤 태스크들이 있는지, 이 태스크들의 Future"
-"는 어떤 상태에 있는지 물어봅니다."
-
-#: src/async/tasks.md:57
-msgid ""
-"This is the first time we've seen an `async` block. This is similar to a "
-"closure, but does not take any arguments. Its return value is a Future, "
-"similar to an `async fn`. "
-msgstr ""
-"`async` 블록을 처음 보게 되었습니다. 이것은 클로저와 비슷하지만 인자를 받지 "
-"않습니다. 리턴 타입은 `async fn`과 비슷한 Future입니다. "
-
-#: src/async/tasks.md:61
-msgid ""
-"Refactor the async block into a function, and improve the error handling "
-"using `?`."
-msgstr ""
-"Async 블록을 함수로 리팩터링하고 `?`를 사용하여 오류 처리를 개선해 봅시다."
-
-#: src/async/channels.md:3
-msgid ""
-"Several crates have support for asynchronous channels. For instance `tokio`:"
-msgstr ""
-"여러 크레이트에서 비동기 채널을 지원합니다. 예를 들어 `tokio`에서는 아래와 같"
-"이합니다."
-
-#: src/async/channels.md:5
-msgid ""
-"```rust,editable,compile_fail\n"
-"use tokio::sync::mpsc::{self, Receiver};\n"
-"\n"
-"async fn ping_handler(mut input: Receiver<()>) {\n"
-"    let mut count: usize = 0;\n"
-"\n"
-"    while let Some(_) = input.recv().await {\n"
-"        count += 1;\n"
-"        println!(\"Received {count} pings so far.\");\n"
-"    }\n"
-"\n"
-"    println!(\"ping_handler complete\");\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let (sender, receiver) = mpsc::channel(32);\n"
-"    let ping_handler_task = tokio::spawn(ping_handler(receiver));\n"
-"    for i in 0..10 {\n"
-"        sender.send(()).await.expect(\"Failed to send ping.\");\n"
-"        println!(\"Sent {} pings so far.\", i + 1);\n"
-"    }\n"
-"\n"
-"    std::mem::drop(sender);\n"
-"    ping_handler_task.await.expect(\"Something went wrong in ping handler "
-"task.\");\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use tokio::sync::mpsc::{self, Receiver};\n"
-"\n"
-"async fn ping_handler(mut input: Receiver<()>) {\n"
-"    let mut count: usize = 0;\n"
-"\n"
-"    while let Some(_) = input.recv().await {\n"
-"        count += 1;\n"
-"        println!(\"Received {count} pings so far.\");\n"
-"    }\n"
-"\n"
-"    println!(\"ping_handler complete\");\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let (sender, receiver) = mpsc::channel(32);\n"
-"    let ping_handler_task = tokio::spawn(ping_handler(receiver));\n"
-"    for i in 0..10 {\n"
-"        sender.send(()).await.expect(\"Failed to send ping.\");\n"
-"        println!(\"Sent {} pings so far.\", i + 1);\n"
-"    }\n"
-"\n"
-"    std::mem::drop(sender);\n"
-"    ping_handler_task.await.expect(\"Something went wrong in ping handler "
-"task.\");\n"
-"}\n"
-"```"
-
-#: src/async/channels.md:35
-msgid "Change the channel size to `3` and see how it affects the execution."
-msgstr "채널 크기를 `3`으로 변경하고 동작이 어떻게 바뀌는지 확인하세요."
-
-#: src/async/channels.md:37
-msgid ""
-"Overall, the interface is similar to the `sync` channels as seen in the "
-"[morning class](concurrency/channels.md)."
-msgstr ""
-"비동기 채널을 사용하기 위한 인터페이스는 [오전 과정](concurrency/channels.md)"
-"에서 배운 `sync` 채널과 비슷합니다."
-
-#: src/async/channels.md:40
-msgid "Try removing the `std::mem::drop` call. What happens? Why?"
-msgstr ""
-"`std::mem::drop` 호출하는 줄을 삭제해 보세요. 어떤 결과가 나타나나요? 이유가 "
-"무엇인가요?"
-
-#: src/async/channels.md:42
-msgid ""
-"The [Flume](https://docs.rs/flume/latest/flume/) crate has channels that "
-"implement both `sync` and `async` `send` and `recv`. This can be convenient "
-"for complex applications with both IO and heavy CPU processing tasks."
-msgstr ""
-"[Flume](https://docs.rs/flume/latest/flume/) 크레이트에는 `sync`와 `async`, "
-"`send`와 `recv`를 모두 구현하는 채널이 있습니다. 이것은 IO와 CPU 처리 작업이 "
-"많은 복잡한 애플리케이션을 구현할 때 매우 유용합니다."
-
-#: src/async/channels.md:46
-msgid ""
-"What makes working with `async` channels preferable is the ability to "
-"combine them with other `future`s to combine them and create complex control "
-"flow."
-msgstr ""
-"`async` 채널을 사용하는 것이 더 좋은 이유는 이를 다른 `future`와 결합하여 복"
-"잡한 제어 흐름을 만들 수 있기 때문입니다."
-
-#: src/async/control-flow.md:3
-msgid ""
-"Futures can be combined together to produce concurrent compute flow graphs. "
-"We have already seen tasks, that function as independent threads of "
-"execution."
-msgstr ""
-"Future들을 결합하여 계산 과정을 동시성이 있는 플로우 그래프 형태로 모델링 할 "
-"수 있습니다. 앞서 배운,  각 태스크가 독립적으로 수행되도록 하는 것도 Future들"
-"을 결합하는 한 방법으로 볼 수 있습니다."
-
-#: src/async/control-flow.md:6
-msgid "[Join](control-flow/join.md)"
-msgstr "[Join](control-flow/join.md)"
-
-#: src/async/control-flow.md:7
-msgid "[Select](control-flow/select.md)"
-msgstr "[Select](control-flow/select.md)"
-
-#: src/async/control-flow/join.md:1 src/SUMMARY.md:287
-msgid "Join"
-msgstr "Join"
-
-#: src/async/control-flow/join.md:3
-msgid ""
-"A join operation waits until all of a set of futures are ready, and returns "
-"a collection of their results. This is similar to `Promise.all` in "
-"JavaScript or `asyncio.gather` in Python."
-msgstr ""
-"Join 연산은 모든 future가 준비될 때까지 기다린 후, 각 future의 결과값을 담은 "
-"컬렉션을 리턴합니다. 이는 자바스크립트의 `Promise.all`이나 파이썬의 `asyncio."
-"gather`와 유사합니다."
-
-#: src/async/control-flow/join.md:7
-msgid ""
-"```rust,editable,compile_fail\n"
-"use anyhow::Result;\n"
-"use futures::future;\n"
-"use reqwest;\n"
-"use std::collections::HashMap;\n"
-"\n"
-"async fn size_of_page(url: &str) -> Result<usize> {\n"
-"    let resp = reqwest::get(url).await?;\n"
-"    Ok(resp.text().await?.len())\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let urls: [&str; 4] = [\n"
-"        \"https://google.com\",\n"
-"        \"https://httpbin.org/ip\",\n"
-"        \"https://play.rust-lang.org/\",\n"
-"        \"BAD_URL\",\n"
-"    ];\n"
-"    let futures_iter = urls.into_iter().map(size_of_page);\n"
-"    let results = future::join_all(futures_iter).await;\n"
-"    let page_sizes_dict: HashMap<&str, Result<usize>> =\n"
-"        urls.into_iter().zip(results.into_iter()).collect();\n"
-"    println!(\"{:?}\", page_sizes_dict);\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use anyhow::Result;\n"
-"use futures::future;\n"
-"use reqwest;\n"
-"use std::collections::HashMap;\n"
-"\n"
-"async fn size_of_page(url: &str) -> Result<usize> {\n"
-"    let resp = reqwest::get(url).await?;\n"
-"    Ok(resp.text().await?.len())\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let urls: [&str; 4] = [\n"
-"        \"https://google.com\",\n"
-"        \"https://httpbin.org/ip\",\n"
-"        \"https://play.rust-lang.org/\",\n"
-"        \"BAD_URL\",\n"
-"    ];\n"
-"    let futures_iter = urls.into_iter().map(size_of_page);\n"
-"    let results = future::join_all(futures_iter).await;\n"
-"    let page_sizes_dict: HashMap<&str, Result<usize>> =\n"
-"        urls.into_iter().zip(results.into_iter()).collect();\n"
-"    println!(\"{:?}\", page_sizes_dict);\n"
-"}\n"
-"```"
-
-#: src/async/control-flow/join.md:38
-msgid ""
-"For multiple futures of disjoint types, you can use `std::future::join!` but "
-"you must know how many futures you will have at compile time. This is "
-"currently in the `futures` crate, soon to be stabilised in `std::future`."
-msgstr ""
-"서로 다른 타입을 가지는 여러 여러 futures들을 join하고자 할 경우 `std::"
-"future::join!`을 사용할 수 있습니다. 이 매크로를 사용하려면 futures가 몇 개"
-"나 있을지 컴파일 할 때 알아야 한다는 점을 주의하세요. 이 매크로는 지금은 "
-"'futures' 크레이트에 있으며 곧 안정화 되어 `std::future`에 포함될 예정입니다."
-
-#: src/async/control-flow/join.md:42
-msgid ""
-"The risk of `join` is that one of the futures may never resolve, this would "
-"cause your program to stall. "
-msgstr ""
-"'join'의 위험성은 futures들 중 하나가 영영 끝나지 않을 수도 있다는 것입니다. "
-"그러면 프로그램이 더이상 진행을 못하고 멈춰있을(stall) 수 있습니다. "
-
-#: src/async/control-flow/join.md:45
-msgid ""
-"You can also combine `join_all` with `join!` for instance to join all "
-"requests to an http service as well as a database query. Try adding a "
-"`tokio::time::sleep` to the future, using `futures::join!`. This is not a "
-"timeout (that requires `select!`, explained in the next chapter), but "
-"demonstrates `join!`."
-msgstr ""
-"`join_all`을 `join!`과 결합하여 http 서비스와 데이터베이스에 대한 모든 요청들"
-"을 한꺼번에 진행시킬 수도 있습니다. `futures::join!`을 사용하여 `tokio::"
-"time::sleep`을 future에 추가해 보세요. 이건 타임아웃을 구현하는 것이 아님을 "
-"주의하세요.  실제로, 타임아웃은 다음 장에서 설명하는 `select!`를 사용해서 구"
-"현해야 합니다.  여기서는 `tokio::time::sleep`을 사용한 것은 단순히 `join!`의 "
-"동작을 설명하기 위함입니다."
-
-#: src/async/control-flow/select.md:3
-msgid ""
-"A select operation waits until any of a set of futures is ready, and "
-"responds to that future's result. In JavaScript, this is similar to `Promise."
-"race`. In Python, it compares to `asyncio.wait(task_set, return_when=asyncio."
-"FIRST_COMPLETED)`."
-msgstr ""
-"Select 연산은 여러 future들 모두에 대해서 준비될 때 까지 기다리다가, 그 중 어"
-"떤 한 future가 최초로 준비 상태가 되면 해당 future의 결과값을 리턴합니다.  이"
-"것은 자바스크립트에서의 `Promise.race`와 비슷합니다. 파이썬에서라면 `asyncio."
-"wait(task_set, return_when=asyncio.FIRST_COMPLETED)`가 하는 동작과 비슷합니"
-"다."
-
-#: src/async/control-flow/select.md:8
-msgid ""
-"Similar to a match statement, the body of `select!` has a number of arms, "
-"each of the form `pattern = future => statement`. When the `future` is "
-"ready, the `statement` is executed with the variables in `pattern` bound to "
-"the `future`'s result."
-msgstr ""
-"`select!` 안에는, `match`문과 비슷하게, `pattern = future => statement` 형태"
-"의 브랜치(arm) 들이 있습니다. 어떤 'future'가 진행 가능 상태가 되면 '그 "
-"`future`의 결과값이 `pattern`으로 바인딩 되며, 그 상태에서 \\`statement'가 수"
-"행됩니다."
-
-#: src/async/control-flow/select.md:13
-msgid ""
-"```rust,editable,compile_fail\n"
-"use tokio::sync::mpsc::{self, Receiver};\n"
-"use tokio::time::{sleep, Duration};\n"
-"\n"
-"#[derive(Debug, PartialEq)]\n"
-"enum Animal {\n"
-"    Cat { name: String },\n"
-"    Dog { name: String },\n"
-"}\n"
-"\n"
-"async fn first_animal_to_finish_race(\n"
-"    mut cat_rcv: Receiver<String>,\n"
-"    mut dog_rcv: Receiver<String>,\n"
-") -> Option<Animal> {\n"
-"    tokio::select! {\n"
-"        cat_name = cat_rcv.recv() => Some(Animal::Cat { name: cat_name? }),\n"
-"        dog_name = dog_rcv.recv() => Some(Animal::Dog { name: dog_name? })\n"
-"    }\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let (cat_sender, cat_receiver) = mpsc::channel(32);\n"
-"    let (dog_sender, dog_receiver) = mpsc::channel(32);\n"
-"    tokio::spawn(async move {\n"
-"        sleep(Duration::from_millis(500)).await;\n"
-"        cat_sender\n"
-"            .send(String::from(\"Felix\"))\n"
-"            .await\n"
-"            .expect(\"Failed to send cat.\");\n"
-"    });\n"
-"    tokio::spawn(async move {\n"
-"        sleep(Duration::from_millis(50)).await;\n"
-"        dog_sender\n"
-"            .send(String::from(\"Rex\"))\n"
-"            .await\n"
-"            .expect(\"Failed to send dog.\");\n"
-"    });\n"
-"\n"
-"    let winner = first_animal_to_finish_race(cat_receiver, dog_receiver)\n"
-"        .await\n"
-"        .expect(\"Failed to receive winner\");\n"
-"\n"
-"    println!(\"Winner is {winner:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use tokio::sync::mpsc::{self, Receiver};\n"
-"use tokio::time::{sleep, Duration};\n"
-"\n"
-"#[derive(Debug, PartialEq)]\n"
-"enum Animal {\n"
-"    Cat { name: String },\n"
-"    Dog { name: String },\n"
-"}\n"
-"\n"
-"async fn first_animal_to_finish_race(\n"
-"    mut cat_rcv: Receiver<String>,\n"
-"    mut dog_rcv: Receiver<String>,\n"
-") -> Option<Animal> {\n"
-"    tokio::select! {\n"
-"        cat_name = cat_rcv.recv() => Some(Animal::Cat { name: cat_name? }),\n"
-"        dog_name = dog_rcv.recv() => Some(Animal::Dog { name: dog_name? })\n"
-"    }\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let (cat_sender, cat_receiver) = mpsc::channel(32);\n"
-"    let (dog_sender, dog_receiver) = mpsc::channel(32);\n"
-"    tokio::spawn(async move {\n"
-"        sleep(Duration::from_millis(500)).await;\n"
-"        cat_sender\n"
-"            .send(String::from(\"Felix\"))\n"
-"            .await\n"
-"            .expect(\"Failed to send cat.\");\n"
-"    });\n"
-"    tokio::spawn(async move {\n"
-"        sleep(Duration::from_millis(50)).await;\n"
-"        dog_sender\n"
-"            .send(String::from(\"Rex\"))\n"
-"            .await\n"
-"            .expect(\"Failed to send dog.\");\n"
-"    });\n"
-"\n"
-"    let winner = first_animal_to_finish_race(cat_receiver, dog_receiver)\n"
-"        .await\n"
-"        .expect(\"Failed to receive winner\");\n"
-"\n"
-"    println!(\"Winner is {winner:?}\");\n"
-"}\n"
-"```"
-
-#: src/async/control-flow/select.md:62
-msgid ""
-"In this example, we have a race between a cat and a dog. "
-"`first_animal_to_finish_race` listens to both channels and will pick "
-"whichever arrives first. Since the dog takes 50ms, it wins against the cat "
-"that take 500ms seconds."
-msgstr ""
-"이 예제에서는 고양이와 개를 경주시켰습니다(동시에 시작시킨 후, 둘 중 먼저 끝"
-"나는 쪽이 이김). `first_animal_to_finish_race`함수는 두 채널 모두에 귀기울이"
-"고(listen하고) 있다가, 메시지가 먼저 도착한 채널을 선택합니다. 개는 50ms만에 "
-"작업을 끝내고 고양이는 500ms가 걸리기 때문에, 개가 이깁니다."
-
-#: src/async/control-flow/select.md:67
-msgid ""
-"You can use `oneshot` channels in this example as the channels are supposed "
-"to receive only one `send`."
-msgstr ""
-"이 예제에서는 `oneshot` 채널을 사용하는 것이 더 좋은 디자인 입니다. 각 채널"
-"이 한 번의 `send`만 수신해야 하는 것이 보장되기 때문입니다."
-
-#: src/async/control-flow/select.md:70
-msgid ""
-"Try adding a deadline to the race, demonstrating selecting different sorts "
-"of futures."
-msgstr ""
-"이 경주에 타임아웃을 추가해서, 서로 다른 종류의 futures들을 동시에 `select`"
-"할 수 있음을 확인해 보세요."
-
-#: src/async/control-flow/select.md:73
-msgid ""
-"Note that `select!` moves the values it is given. It is easiest to use when "
-"every execution of `select!` creates new futures. An alternative is to pass "
-"`&mut future` instead of the future itself, but this can lead to issues, "
-"further discussed in the pinning slide."
-msgstr ""
-"`select!`는 매칭되지 않은 다른 모든 브랜치에 대해 drop을 수행합니다. 따라서 "
-"경쟁에서 진 모든 future들은  취소(cancel) 됩니다. `select!`를 실행할 때마다 "
-"새로운 futures가 만들어지는 경우라면, 이러한 점이 매우 편하게 느껴질 것입니"
-"다. Future가 취소되는 것을 막기 위해 future를 직접 전달하는 대신 `&mut "
-"future`를 전달하는 것도 가능합니다.  하지만 이렇게 하면 문제가 발생할 수 있습"
-"니다 (왜 그런지는 `Pin`설명할 때 자세히 설명하겠습니다)."
-
-#: src/async/pitfalls.md:1
-msgid "Pitfalls of async/await"
-msgstr "async/await에서 주의해야할 함정"
-
-#: src/async/pitfalls.md:3
-msgid ""
-"Async / await provides convenient and efficient abstraction for concurrent "
-"asynchronous programming. However, the async/await model in Rust also comes "
-"with its share of pitfalls and footguns. We illustrate some of them in this "
-"chapter:"
-msgstr ""
-"Async와 await는 동시 비동기 프로그래밍을 위한 편리하고 효율적인 추상화를 제공"
-"합니다. 하지만 Rust의 async/await 모델에도 문제는 있습니다. 이 장에서 몇 가"
-"지 예를 살펴보겠습니다."
-
-#: src/async/pitfalls.md:5
-msgid "[Blocking the Executor](pitfalls/blocking-executor.md)"
-msgstr "[실행자 차단](pitfalls/blocking-executor.md)"
-
-#: src/async/pitfalls.md:6
-msgid "[Pin](pitfalls/pin.md)"
-msgstr "[고정](pitfalls/pin.md)"
-
-#: src/async/pitfalls.md:7
-msgid "[Async Traits](pitfall/async-traits.md)"
-msgstr "[비동기 트레잇](pitfall/async-traits.md)"
-
-#: src/async/pitfalls/blocking-executor.md:1
-msgid "Blocking the executor"
-msgstr "실행자(executor)를 블록시킴"
-
-#: src/async/pitfalls/blocking-executor.md:3
-msgid ""
-"Most async runtimes only allow IO tasks to run concurrently. This means that "
-"CPU blocking tasks will block the executor and prevent other tasks from "
-"being executed. An easy workaround is to use async equivalent methods where "
-"possible."
-msgstr ""
-"대부분의 비동기 런타임은 IO 작업만 동시에 실행되도록 허용합니다. 즉, CPU를 블"
-"럭하는 태스크가 있는 경우, 이는 실행자(executor)를 블럭하게 되며, 그 결과로 "
-"다른 태스크가 실행되지 않습니다. 이 문제를 해결하는 간단한 방법은, 항상 async"
-"를 지원하는 메서드를 사용하는 것입니다."
-
-#: src/async/pitfalls/blocking-executor.md:7
-msgid ""
-"```rust,editable,compile_fail\n"
-"use futures::future::join_all;\n"
-"use std::time::Instant;\n"
-"\n"
-"async fn sleep_ms(start: &Instant, id: u64, duration_ms: u64) {\n"
-"    std::thread::sleep(std::time::Duration::from_millis(duration_ms));\n"
-"    println!(\n"
-"        \"future {id} slept for {duration_ms}ms, finished after {}ms\",\n"
-"        start.elapsed().as_millis()\n"
-"    );\n"
-"}\n"
-"\n"
-"#[tokio::main(flavor = \"current_thread\")]\n"
-"async fn main() {\n"
-"    let start = Instant::now();\n"
-"    let sleep_futures = (1..=10).map(|t| sleep_ms(&start, t, t * 10));\n"
-"    join_all(sleep_futures).await;\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use futures::future::join_all;\n"
-"use std::time::Instant;\n"
-"\n"
-"async fn sleep_ms(start: &Instant, id: u64, duration_ms: u64) {\n"
-"    std::thread::sleep(std::time::Duration::from_millis(duration_ms));\n"
-"    println!(\n"
-"        \"future {id} slept for {duration_ms}ms, finished after {}ms\",\n"
-"        start.elapsed().as_millis()\n"
-"    );\n"
-"}\n"
-"\n"
-"#[tokio::main(flavor = \"current_thread\")]\n"
-"async fn main() {\n"
-"    let start = Instant::now();\n"
-"    let sleep_futures = (1..=10).map(|t| sleep_ms(&start, t, t * 10));\n"
-"    join_all(sleep_futures).await;\n"
-"}\n"
-"```"
-
-#: src/async/pitfalls/blocking-executor.md:29
-msgid ""
-"Run the code and see that the sleeps happen consecutively rather than "
-"concurrently."
-msgstr ""
-"코드를 실행하여 sleep들이 동시에 진행되지 않고 순차적으로으로 진행되는지 확인"
-"하세요."
-
-#: src/async/pitfalls/blocking-executor.md:32
-msgid ""
-"The `\"current_thread\"` flavor puts all tasks on a single thread. This "
-"makes the effect more obvious, but the bug is still present in the multi-"
-"threaded flavor."
-msgstr ""
-"`flavor`를 `\"current_thread\"` 로 설정하면 모든 태스크가 하나의 스레드에서 "
-"수행됩니다. 이렇게 하면 문제 상황이 더 분명히 드러납니다. 그러나 이 버그는 멀"
-"티스레드인 경우에도 여전히 존재합니다."
-
-#: src/async/pitfalls/blocking-executor.md:36
-msgid ""
-"Switch the `std::thread::sleep` to `tokio::time::sleep` and await its result."
-msgstr ""
-"`std::thread::sleep`을 `tokio::time::sleep`으로 바꾸고 그 결과를 `await`해 보"
-"세요."
-
-#: src/async/pitfalls/blocking-executor.md:38
-msgid ""
-"Another fix would be to `tokio::task::spawn_blocking` which spawns an actual "
-"thread and transforms its handle into a future without blocking the executor."
-msgstr ""
-"또 다른 해결 방법은 `tokio::task::spawn_blocking`입니다. 이는 실제 스레드를 "
-"생성하고, 그 스레드에 대한 핸들을 future로 변환함으로써 실행자가 블록되는 것"
-"을 막습니다."
-
-#: src/async/pitfalls/blocking-executor.md:41
-msgid ""
-"You should not think of tasks as OS threads. They do not map 1 to 1 and most "
-"executors will allow many tasks to run on a single OS thread. This is "
-"particularly problematic when interacting with other libraries via FFI, "
-"where that library might depend on thread-local storage or map to specific "
-"OS threads (e.g., CUDA). Prefer `tokio::task::spawn_blocking` in such "
-"situations."
-msgstr ""
-"태스크를 OS 스레드라고 생각하면 안 됩니다. 태스크와 OS스레드는 일대일 매핑 관"
-"계에 있지 않습니다. 대부분의 실행자는 하나의 OS 스레드에서 최대한 많은 태스크"
-"를 수행하도록 설계되어 있습니다. 이점은 FFI를 통해 다른 라이브러리와 상호작용"
-"할 때 특히 문제가 됩니다. 예를 들어, 해당 라이브러리가 스레드 로컬 저장소를 "
-"이용하거나 특정 OS 스레드에 매핑될 수 있습니다(예: CUDA). 이러한 상황에서는 "
-"`tokio::task::spawn_blocking`을 사용하는 것이 좋습니다."
-
-#: src/async/pitfalls/blocking-executor.md:47
-msgid ""
-"Use sync mutexes with care. Holding a mutex over an `.await` may cause "
-"another task to block, and that task may be running on the same thread."
-msgstr ""
-"동기화 뮤텍스를 주의해서 사용하세요. `.await` 위에 뮤텍스를 적용하면 다른 작"
-"업이 차단될 수 있으며 해당 작업은 동일한 스레드에서 실행 중일 수 있습니다."
-
-#: src/async/pitfalls/pin.md:1 src/SUMMARY.md:291
-msgid "Pin"
-msgstr "Future 고정(Pin)하기"
-
-#: src/async/pitfalls/pin.md:3
-msgid ""
-"When you await a future, all local variables (that would ordinarily be "
-"stored on a stack frame) are instead stored in the Future for the current "
-"async block. If your future has pointers to data on the stack, those "
-"pointers might get invalidated. This is unsafe."
-msgstr ""
-"Future에 대해 `await`를 호출하여 그 future가 준비되기를 기다릴 때, 모든 로컬 "
-"변수(일반적으로 스택 프레임에 저장됨)는 그 future객체 안에 저장됩니다.  만약 "
-"그 future에 스택에 있는 어떤 데이터로의 포인터가 있으면 이러한 포인터는 올바"
-"르지 않을 수 있습니다. 안전하지 않습니다."
-
-#: src/async/pitfalls/pin.md:8
-msgid ""
-"Therefore, you must guarantee that the addresses your future points to don't "
-"change. That is why we need to `pin` futures. Using the same future "
-"repeatedly in a `select!` often leads to issues with pinned values."
-msgstr ""
-"따라서 future가 가리키는 주소가 변경되지 않도록 해야 합니다. 이것이 future를 "
-"`pin`(고정)해야 하는 이유입니다. `select!`에서 동일한 future를 반복적으로 사"
-"용하면 고정 값 문제가 발생하는 경우가 많습니다."
-
-#: src/async/pitfalls/pin.md:12
-msgid ""
-"```rust,editable,compile_fail\n"
-"use tokio::sync::{mpsc, oneshot};\n"
-"use tokio::task::spawn;\n"
-"use tokio::time::{sleep, Duration};\n"
-"\n"
-"// A work item. In this case, just sleep for the given time and respond\n"
-"// with a message on the `respond_on` channel.\n"
 "#[derive(Debug)]\n"
-"struct Work {\n"
-"    input: u32,\n"
-"    respond_on: oneshot::Sender<u32>,\n"
+"struct DirectoryIterator {\n"
+"    path: CString,\n"
+"    dir: *mut ffi::DIR,\n"
 "}\n"
 "\n"
-"// A worker which listens for work on a queue and performs it.\n"
-"async fn worker(mut work_queue: mpsc::Receiver<Work>) {\n"
-"    let mut iterations = 0;\n"
-"    loop {\n"
-"        tokio::select! {\n"
-"            Some(work) = work_queue.recv() => {\n"
-"                sleep(Duration::from_millis(10)).await; // Pretend to work.\n"
-"                work.respond_on\n"
-"                    .send(work.input * 1000)\n"
-"                    .expect(\"failed to send response\");\n"
-"                iterations += 1;\n"
-"            }\n"
-"            // TODO: report number of iterations every 100ms\n"
-"        }\n"
+"impl DirectoryIterator {\n"
+"    fn new(path: &str) -> Result<DirectoryIterator, String> {\n"
+"        // Call opendir and return a Ok value if that worked,\n"
+"        // otherwise return Err with a message.\n"
+"        unimplemented!()\n"
 "    }\n"
 "}\n"
 "\n"
-"// A requester which requests work and waits for it to complete.\n"
-"async fn do_work(work_queue: &mpsc::Sender<Work>, input: u32) -> u32 {\n"
-"    let (tx, rx) = oneshot::channel();\n"
-"    work_queue\n"
-"        .send(Work {\n"
-"            input,\n"
-"            respond_on: tx,\n"
-"        })\n"
-"        .await\n"
-"        .expect(\"failed to send on work queue\");\n"
-"    rx.await.expect(\"failed waiting for response\")\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let (tx, rx) = mpsc::channel(10);\n"
-"    spawn(worker(rx));\n"
-"    for i in 0..100 {\n"
-"        let resp = do_work(&tx, i).await;\n"
-"        println!(\"work result for iteration {i}: {resp}\");\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use tokio::sync::{mpsc, oneshot};\n"
-"use tokio::task::spawn;\n"
-"use tokio::time::{sleep, Duration};\n"
-"\n"
-"// 작업 항목. 이 경우 지정된 시간 동안 절전 모드로 있다가\n"
-"// `respond_on` 채널의 메시지로 응답합니다.\n"
-"#[derive(Debug)]\n"
-"struct Work {\n"
-"    input: u32,\n"
-"    respond_on: oneshot::Sender<u32>,\n"
-"}\n"
-"\n"
-"// 대기열에서 작업을 리슨하고 실행하는 worker입니다.\n"
-"async fn worker(mut work_queue: mpsc::Receiver<Work>) {\n"
-"    let mut iterations = 0;\n"
-"    loop {\n"
-"        tokio::select! {\n"
-"            Some(work) = work_queue.recv() => {\n"
-"                sleep(Duration::from_millis(10)).await; // Pretend to work.\n"
-"                work.respond_on\n"
-"                    .send(work.input * 1000)\n"
-"                    .expect(\"failed to send response\");\n"
-"                iterations += 1;\n"
-"            }\n"
-"            // TODO: 100ms마다 반복 횟수를 보고합니다.\n"
-"        }\n"
+"impl Iterator for DirectoryIterator {\n"
+"    type Item = OsString;\n"
+"    fn next(&mut self) -> Option<OsString> {\n"
+"        // Keep calling readdir until we get a NULL pointer back.\n"
+"        unimplemented!()\n"
 "    }\n"
 "}\n"
 "\n"
-"// 작업을 요청하고 작업이 완료될 때까지 기다리는 요청자입니다.\n"
-"async fn do_work(work_queue: &mpsc::Sender<Work>, input: u32) -> u32 {\n"
-"    let (tx, rx) = oneshot::channel();\n"
-"    work_queue\n"
-"        .send(Work {\n"
-"            input,\n"
-"            respond_on: tx,\n"
-"        })\n"
-"        .await\n"
-"        .expect(\"failed to send on work queue\");\n"
-"    rx.await.expect(\"failed waiting for response\")\n"
+"impl Drop for DirectoryIterator {\n"
+"    fn drop(&mut self) {\n"
+"        // Call closedir as needed.\n"
+"        unimplemented!()\n"
+"    }\n"
 "}\n"
 "\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let (tx, rx) = mpsc::channel(10);\n"
-"    spawn(worker(rx));\n"
-"    for i in 0..100 {\n"
-"        let resp = do_work(&tx, i).await;\n"
-"        println!(\"work result for iteration {i}: {resp}\");\n"
-"    }\n"
+"fn main() -> Result<(), String> {\n"
+"    let iter = DirectoryIterator::new(\".\")?;\n"
+"    println!(\"files: {:#?}\", iter.collect::<Vec<_>>());\n"
+"    Ok(())\n"
 "}\n"
 "```"
 
-#: src/async/pitfalls/pin.md:68
-msgid ""
-"You may recognize this as an example of the actor pattern. Actors typically "
-"call `select!` in a loop."
-msgstr ""
-"위에서 소개한 것은 액터(actor) 패턴의 한 예라고 봐도 무방합니다. 액터는 일반"
-"적으로 루프 안에서 `select!`를 호출합니다."
-
-#: src/async/pitfalls/pin.md:71
-msgid ""
-"This serves as a summation of a few of the previous lessons, so take your "
-"time with it."
-msgstr "이전 강의 몇 개의 내용을 요약한 것이기 때문에 천천히 살펴보세요."
-
-#: src/async/pitfalls/pin.md:74
-msgid ""
-"Naively add a `_ = sleep(Duration::from_millis(100)) => { println!(..) }` to "
-"the `select!`. This will never execute. Why?"
-msgstr ""
-"`_ = sleep(Duration::from_millis(100)) => { println!(..) }`을 `select!`에 추"
-"가해 보세요. 이 작업은 실행되지 않습니다. 왜 그럴까요?"
-
-#: src/async/pitfalls/pin.md:77
-msgid ""
-"Instead, add a `timeout_fut` containing that future outside of the `loop`:"
-msgstr ""
-"대신, 해당 future가 포함된 `timeout_fut`를 `loop` 외부에 추가해 보세요."
-
-#: src/async/pitfalls/pin.md:79
-msgid ""
-"```rust,compile_fail\n"
-"let mut timeout_fut = sleep(Duration::from_millis(100));\n"
-"loop {\n"
-"    select! {\n"
-"        ..,\n"
-"        _ = timeout_fut => { println!(..); },\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,compile_fail\n"
-"let mut timeout_fut = sleep(Duration::from_millis(100));\n"
-"loop {\n"
-"    select! {\n"
-"        ..,\n"
-"        _ = timeout_fut => { println!(..); },\n"
-"    }\n"
-"}\n"
-"```"
-
-#: src/async/pitfalls/pin.md:88
-msgid ""
-"This still doesn't work. Follow the compiler errors, adding `&mut` to the "
-"`timeout_fut` in the `select!` to work around the move, then using `Box::"
-"pin`:"
-msgstr ""
-"여전히 작동하지 않습니다. 컴파일러 오류를 따라 `select!`의 `timeout_fut`에 "
-"`&mut`를 추가하여 Move 시멘틱 관련한 문제를 해결하고 `Box::pin`을 사용하세요."
-
-#: src/async/pitfalls/pin.md:92
-msgid ""
-"```rust,compile_fail\n"
-"let mut timeout_fut = Box::pin(sleep(Duration::from_millis(100)));\n"
-"loop {\n"
-"    select! {\n"
-"        ..,\n"
-"        _ = &mut timeout_fut => { println!(..); },\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,compile_fail\n"
-"let mut timeout_fut = Box::pin(sleep(Duration::from_millis(100)));\n"
-"loop {\n"
-"    select! {\n"
-"        ..,\n"
-"        _ = &mut timeout_fut => { println!(..); },\n"
-"    }\n"
-"}\n"
-"```"
-
-#: src/async/pitfalls/pin.md:102
-msgid ""
-"This compiles, but once the timeout expires it is `Poll::Ready` on every "
-"iteration (a fused future would help with this). Update to reset "
-"`timeout_fut` every time it expires."
-msgstr ""
-"이는 컴파일은 되지만 타임 아웃이 되면 매번 반복할 때 마다 `Poll::Ready`가 됩"
-"니다(융합된 future가 도움이 될 수 있음). 타임 아웃 될 때마다 `timeout_fut`를 "
-"리셋하도록 수정하세요."
-
-#: src/async/pitfalls/pin.md:106
-msgid ""
-"Box allocates on the heap. In some cases, `std::pin::pin!` (only recently "
-"stabilized, with older code often using `tokio::pin!`) is also an option, "
-"but that is difficult to use for a future that is reassigned."
-msgstr ""
-"Box는 힙에 할당합니다. 경우에 따라 `std::pin::pin!`(최근에야 안정화되었으며 "
-"이전 코드는 `tokio::pin!`을 사용하는 경우가 많음)도 사용할 수 있지만 이는 재"
-"할당된 future에 사용하기가 어렵습니다."
-
-#: src/async/pitfalls/pin.md:110
-msgid ""
-"Another alternative is to not use `pin` at all but spawn another task that "
-"will send to a `oneshot` channel every 100ms."
-msgstr ""
-"또 다른 방법은 `pin`을 아예 사용하지 않고 100ms마다 `oneshot` 채널에 전송할 "
-"다른 작업을 생성하는 것입니다."
-
-#: src/async/pitfalls/async-traits.md:3
-msgid ""
-"Async methods in traits are not yet supported in the stable channel ([An "
-"experimental feature exists in nightly and should be stabilized in the mid "
-"term.](https://blog.rust-lang.org/inside-rust/2022/11/17/async-fn-in-trait-"
-"nightly.html))"
-msgstr ""
-"트레잇에 async 메소드를 추가하는 것은 아직 안정화 버전 채널에서 지원되지 않습"
-"니다([실험용 기능은 nightly에 존재하며 조만간 안정화 될 것입니다](https://"
-"blog.rust-lang.org/inside-rust/2022/11/17/async-fn-in-trait-nightly.html))."
-
-#: src/async/pitfalls/async-traits.md:5
-msgid ""
-"The crate [async_trait](https://docs.rs/async-trait/latest/async_trait/) "
-"provides a workaround through a macro:"
-msgstr ""
-"크레이트 [async_trait](https://docs.rs/async-trait/latest/async_trait/)은 매"
-"크로를 통한 해결 방법을 제공합니다."
-
-#: src/async/pitfalls/async-traits.md:7
-msgid ""
-"```rust,editable,compile_fail\n"
-"use async_trait::async_trait;\n"
-"use std::time::Instant;\n"
-"use tokio::time::{sleep, Duration};\n"
-"\n"
-"#[async_trait]\n"
-"trait Sleeper {\n"
-"    async fn sleep(&self);\n"
-"}\n"
-"\n"
-"struct FixedSleeper {\n"
-"    sleep_ms: u64,\n"
-"}\n"
-"\n"
-"#[async_trait]\n"
-"impl Sleeper for FixedSleeper {\n"
-"    async fn sleep(&self) {\n"
-"        sleep(Duration::from_millis(self.sleep_ms)).await;\n"
-"    }\n"
-"}\n"
-"\n"
-"async fn run_all_sleepers_multiple_times(sleepers: Vec<Box<dyn Sleeper>>, "
-"n_times: usize) {\n"
-"    for _ in 0..n_times {\n"
-"        println!(\"running all sleepers..\");\n"
-"        for sleeper in &sleepers {\n"
-"            let start = Instant::now();\n"
-"            sleeper.sleep().await;\n"
-"            println!(\"slept for {}ms\", start.elapsed().as_millis());\n"
-"        }\n"
-"    }\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let sleepers: Vec<Box<dyn Sleeper>> = vec![\n"
-"        Box::new(FixedSleeper { sleep_ms: 50 }),\n"
-"        Box::new(FixedSleeper { sleep_ms: 100 }),\n"
-"    ];\n"
-"    run_all_sleepers_multiple_times(sleepers, 5).await;\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use async_trait::async_trait;\n"
-"use std::time::Instant;\n"
-"use tokio::time::{sleep, Duration};\n"
-"\n"
-"#[async_trait]\n"
-"trait Sleeper {\n"
-"    async fn sleep(&self);\n"
-"}\n"
-"\n"
-"struct FixedSleeper {\n"
-"    sleep_ms: u64,\n"
-"}\n"
-"\n"
-"#[async_trait]\n"
-"impl Sleeper for FixedSleeper {\n"
-"    async fn sleep(&self) {\n"
-"        sleep(Duration::from_millis(self.sleep_ms)).await;\n"
-"    }\n"
-"}\n"
-"\n"
-"async fn run_all_sleepers_multiple_times(sleepers: Vec<Box<dyn Sleeper>>, "
-"n_times: usize) {\n"
-"    for _ in 0..n_times {\n"
-"        println!(\"running all sleepers..\");\n"
-"        for sleeper in &sleepers {\n"
-"            let start = Instant::now();\n"
-"            sleeper.sleep().await;\n"
-"            println!(\"slept for {}ms\", start.elapsed().as_millis());\n"
-"        }\n"
-"    }\n"
-"}\n"
-"\n"
-"#[tokio::main]\n"
-"async fn main() {\n"
-"    let sleepers: Vec<Box<dyn Sleeper>> = vec![\n"
-"        Box::new(FixedSleeper { sleep_ms: 50 }),\n"
-"        Box::new(FixedSleeper { sleep_ms: 100 }),\n"
-"    ];\n"
-"    run_all_sleepers_multiple_times(sleepers, 5).await;\n"
-"}\n"
-"```"
-
-#: src/async/pitfalls/async-traits.md:51
-msgid ""
-"`async_trait` is easy to use, but note that it's using heap allocations to "
-"achieve this. This heap allocation has performance overhead."
-msgstr ""
-"`async_trait`은 사용하기 쉽지만 이를 위해 힙에 메모리를  할당한다는 점에 유의"
-"하세요. 이 힙 할당에는 성능 오버헤드가 있습니다."
-
-#: src/async/pitfalls/async-traits.md:54
-msgid ""
-"The challenges in language support for `async trait` are deep Rust and "
-"probably not worth describing in-depth. Niko Matsakis did a good job of "
-"explaining them in [this post](https://smallcultfollowing.com/babysteps/"
-"blog/2019/10/26/async-fn-in-traits-are-hard/) if you are interested in "
-"digging deeper."
-msgstr ""
-"`async trait` 를 언어 차원에서 지원하는 것과 관련된 문제는 매우 전문적인 토픽"
-"이며 따라서 이 강의에서 다룰 내용은 아닙니다. [이 게시물](https://"
-"smallcultfollowing.com/babysteps/blog/2019/10/26/async-fn-in-traits-are-"
-"hard/)에 이에 관한 니코 마사키스의 좋은 설명이 있으므로 관심이 있다면 참고하"
-"세요."
-
-#: src/async/pitfalls/async-traits.md:60
-msgid ""
-"Try creating a new sleeper struct that will sleep for a random amount of "
-"time and adding it to the Vec."
-msgstr ""
-"임의의 시간 동안 sleep 하는 새로운 sleeper 구조체를 만들어 Vec에 추가해 보세"
-"요."
-
-#: src/exercises/day-4/morning.md:3
-msgid "Let us practice our new concurrency skills with"
-msgstr "동시성 기법들을 연습해 봅시다"
-
-#: src/exercises/day-4/morning.md:5
-msgid "Dining philosophers: a classic problem in concurrency."
-msgstr "식사하는 철학자 문제: 고적적인 동시성 문제입니다."
-
-#: src/exercises/day-4/morning.md:7
-msgid ""
-"Multi-threaded link checker: a larger project where you'll use Cargo to "
-"download dependencies and then check links in parallel."
-msgstr ""
-"멀티 스레드 링크 검사기: 병렬적으로 웹페이지의 링크들을 체크합니다. 카고를 통"
-"해 몇 가지 의존성들을 다운도르 받아야 하는 큰 프로젝트 입니다."
-
-#: src/exercises/day-4/dining-philosophers.md:3
-msgid "The dining philosophers problem is a classic problem in concurrency:"
-msgstr "식사하는 철학자 문제는 동시성에 있어서 고전적인 문제입니다:"
-
-#: src/exercises/day-4/dining-philosophers.md:5
-msgid ""
-"Five philosophers dine together at the same table. Each philosopher has "
-"their own place at the table. There is a fork between each plate. The dish "
-"served is a kind of spaghetti which has to be eaten with two forks. Each "
-"philosopher can only alternately think and eat. Moreover, a philosopher can "
-"only eat their spaghetti when they have both a left and right fork. Thus two "
-"forks will only be available when their two nearest neighbors are thinking, "
-"not eating. After an individual philosopher finishes eating, they will put "
-"down both forks."
-msgstr ""
-"5명의 철학자가 원탁에서 식사를 하고 있습니다.  철학자는 원탁에서 자신의 자리"
-"에 앉아있습니다. 포크는 각 접시 사이에 있습니다.  제공되는 요리를 먹기 위해서"
-"는 두 개의 포크를 모두 사용해야합니다. 철학자는 생각을 하다가 배가 고프면 자"
-"신의 좌,우의 포크를 들어 요리를 먹습니다. 철학자는 요리를 먹은 후에는 포크를 "
-"다시 자리에 내려놓습니다. 철학자는 자신의 좌,우에 포크가 있을때만 요리를 먹"
-"을 수 있습니다. 따라서 두 개의 포크는 오직 자신의 좌,우 철학자가 생각을 할 때"
-"만 사용할 수 있습니다."
-
-#: src/exercises/day-4/dining-philosophers.md:13
-msgid ""
-"You will need a local [Cargo installation](../../cargo/running-locally.md) "
-"for this exercise. Copy the code below to `src/main.rs` file, fill out the "
-"blanks, and test that `cargo run` does not deadlock:"
-msgstr ""
-"이번 훈련에서는 [카고 설치하기](../../cargo/running-locally.md)가 필요합니"
-"다. 아래 코드를 복사해서 `src/main.rs`에 붙여놓고 빈 부분을 채우고, `cargo "
-"run` 커맨드로 테스트 해서 교착상태(데드락)가 발생하지 않는지 확인합니다:"
-
-#: src/exercises/day-4/dining-philosophers.md:17
-msgid ""
-"```rust,compile_fail\n"
-"use std::sync::mpsc;\n"
-"use std::sync::{Arc, Mutex};\n"
-"use std::thread;\n"
-"use std::time::Duration;\n"
-"\n"
-"struct Fork;\n"
-"\n"
-"struct Philosopher {\n"
-"    name: String,\n"
-"    // left_fork: ...\n"
-"    // right_fork: ...\n"
-"    // thoughts: ...\n"
-"}\n"
-"\n"
-"impl Philosopher {\n"
-"    fn think(&self) {\n"
-"        self.thoughts\n"
-"            .send(format!(\"Eureka! {} has a new idea!\", &self.name))\n"
-"            .unwrap();\n"
-"    }\n"
-"\n"
-"    fn eat(&self) {\n"
-"        // Pick up forks...\n"
-"        println!(\"{} is eating...\", &self.name);\n"
-"        thread::sleep(Duration::from_millis(10));\n"
-"    }\n"
-"}\n"
-"\n"
-"static PHILOSOPHERS: &[&str] =\n"
-"    &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];\n"
-"\n"
-"fn main() {\n"
-"    // Create forks\n"
-"\n"
-"    // Create philosophers\n"
-"\n"
-"    // Make them think and eat\n"
-"\n"
-"    // Output their thoughts\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/exercises/day-4/link-checker.md:3
-msgid ""
-"Let us use our new knowledge to create a multi-threaded link checker. It "
-"should start at a webpage and check that links on the page are valid. It "
-"should recursively check other pages on the same domain and keep doing this "
-"until all pages have been validated."
-msgstr ""
-"새로 배운것들을 활용해서 멀티 스레드 링크 검사기를 만듭니다. 이 검사기는 웹페"
-"이지 안에 있는 링크들이 유효한지 확인합니다. 그리고 재귀적으로 동일 도메인의 "
-"다른 모든 페이지가 유효한지 확인합니다."
-
-#: src/exercises/day-4/link-checker.md:8
-msgid ""
-"For this, you will need an HTTP client such as \\[`reqwest`\\]\\[1\\]. "
-"Create a new Cargo project and `reqwest` it as a dependency with:"
-msgstr ""
-"이를 위해서 \\[`reqwest`\\]\\[1\\]와 같은 HTTP 클라이언트가 필요합니다. 새로"
-"운 로컬 프로젝트를 만들고 \\[`reqwest`\\]\\[1\\]를 의존성에 추가하십시요:"
-
-#: src/exercises/day-4/link-checker.md:11
-msgid ""
-"```shell\n"
-"$ cargo new link-checker\n"
-"$ cd link-checker\n"
-"$ cargo add --features blocking,rustls-tls reqwest\n"
-"```"
-msgstr ""
-
-#: src/exercises/day-4/link-checker.md:17
-msgid ""
-"If `cargo add` fails with `error: no such subcommand`, then please edit the "
-"`Cargo.toml` file by hand. Add the dependencies listed below."
-msgstr ""
-"만일 `cargo add` 커맨드가 `error: no such subcommand` 로 실패한다면 `Cargo."
-"toml` 파일을 직접 수정해도 됩니다. 아래에 전체 의존성 내용이 있습니다."
-
-#: src/exercises/day-4/link-checker.md:20
-msgid ""
-"You will also need a way to find links. We can use \\[`scraper`\\]\\[2\\] "
-"for that:"
-msgstr "링크를 찾기 위해서 \\[`scraper`\\]\\[2\\]도 추가합니다:"
-
-#: src/exercises/day-4/link-checker.md:22
-msgid ""
-"```shell\n"
-"$ cargo add scraper\n"
-"```"
-msgstr ""
-
-#: src/exercises/day-4/link-checker.md:26
-msgid ""
-"Finally, we'll need some way of handling errors. We use "
-"\\[`thiserror`\\]\\[3\\] for that:"
-msgstr ""
-"마지막으로 오류 처리하는 방법으로 \\[`thiserror`\\]\\[3\\]도 추가합니다:"
-
-#: src/exercises/day-4/link-checker.md:29
-msgid ""
-"```shell\n"
-"$ cargo add thiserror\n"
-"```"
-msgstr ""
-
-#: src/exercises/day-4/link-checker.md:33
-msgid ""
-"The `cargo add` calls will update the `Cargo.toml` file to look like this:"
-msgstr "모든 `cargo add`가 끝나면 `Cargo.toml`에 아래 내용이 추가됩니다:"
-
-#: src/exercises/day-4/link-checker.md:35
-msgid ""
-"```toml\n"
-"[dependencies]\n"
-"reqwest = { version = \"0.11.12\", features = [\"blocking\", \"rustls-"
-"tls\"] }\n"
-"scraper = \"0.13.0\"\n"
-"thiserror = \"1.0.37\"\n"
-"```"
-msgstr ""
-
-#: src/exercises/day-4/link-checker.md:42
-msgid ""
-"You can now download the start page. Try with a small site such as `https://"
-"www.google.org/`."
-msgstr "이제 `https://www.google.org/` 같은 웹 페이지를 탐색할 수 있습니다."
-
-#: src/exercises/day-4/link-checker.md:45
-msgid "Your `src/main.rs` file should look something like this:"
-msgstr "`rc/main.rs`파일은 아래와 같습니다:"
-
-#: src/exercises/day-4/link-checker.md:47
-msgid ""
-"```rust,compile_fail\n"
-"use reqwest::blocking::{get, Response};\n"
-"use reqwest::Url;\n"
-"use scraper::{Html, Selector};\n"
-"use thiserror::Error;\n"
-"\n"
-"#[derive(Error, Debug)]\n"
-"enum Error {\n"
-"    #[error(\"request error: {0}\")]\n"
-"    ReqwestError(#[from] reqwest::Error),\n"
-"}\n"
-"\n"
-"fn extract_links(response: Response) -> Result<Vec<Url>, Error> {\n"
-"    let base_url = response.url().to_owned();\n"
-"    let document = response.text()?;\n"
-"    let html = Html::parse_document(&document);\n"
-"    let selector = Selector::parse(\"a\").unwrap();\n"
-"\n"
-"    let mut valid_urls = Vec::new();\n"
-"    for element in html.select(&selector) {\n"
-"        if let Some(href) = element.value().attr(\"href\") {\n"
-"            match base_url.join(href) {\n"
-"                Ok(url) => valid_urls.push(url),\n"
-"                Err(err) => {\n"
-"                    println!(\"On {base_url}: could not parse {href:?}: "
-"{err} (ignored)\",);\n"
-"                }\n"
-"            }\n"
-"        }\n"
-"    }\n"
-"\n"
-"    Ok(valid_urls)\n"
-"}\n"
-"\n"
-"fn main() {\n"
-"    let start_url = Url::parse(\"https://www.google.org\").unwrap();\n"
-"    let response = get(start_url).unwrap();\n"
-"    match extract_links(response) {\n"
-"        Ok(links) => println!(\"Links: {links:#?}\"),\n"
-"        Err(err) => println!(\"Could not extract links: {err:#}\"),\n"
-"    }\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/exercises/day-4/link-checker.md:90
-msgid "Run the code in `src/main.rs` with"
-msgstr "아래 커맨드로 소스를 실행합니다"
-
-#: src/exercises/day-4/link-checker.md:92
-msgid ""
-"```shell\n"
-"$ cargo run\n"
-"```"
-msgstr ""
-
-#: src/exercises/day-4/link-checker.md:96
-msgid "Tasks"
-msgstr "할 일"
-
-#: src/exercises/day-4/link-checker.md:98
-msgid ""
-"Use threads to check the links in parallel: send the URLs to be checked to a "
-"channel and let a few threads check the URLs in parallel."
-msgstr ""
-"스레드를 사용하여 링크를 병렬로 확인합니다: URL을 채널로 보내서 몇 개의 스레"
-"드가 URL을 병렬로 체크하도록 합니다."
-
-#: src/exercises/day-4/link-checker.md:100
-msgid ""
-"Extend this to recursively extract links from all pages on the `www.google."
-"org` domain. Put an upper limit of 100 pages or so so that you don't end up "
-"being blocked by the site."
-msgstr ""
-"`www.google.org`도메인의 모든 페이지를 재귀적으로 확인하기 위해 코드를 확장해"
-"서 작성합니다: 차단당하지 않도록 100페이지 정도로 제한을 두시기 바랍니다."
+#: src/android.md:1
+#, fuzzy
+msgid "Welcome to Rust in Android"
+msgstr "1일차 개요"
 
 #: src/android.md:3
 msgid ""
@@ -16548,11 +15443,12 @@ msgstr ""
 "수행할 겁니다. 새로운 가상 디바이스를 생성하려면 아래의 명령어를 사용하세요:"
 
 #: src/android/setup.md:6
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ source build/envsetup.sh\n"
-"$ lunch aosp_cf_x86_64_phone-userdebug\n"
-"$ acloud create\n"
+"source build/envsetup.sh\n"
+"lunch aosp_cf_x86_64_phone-userdebug\n"
+"acloud create\n"
 "```"
 msgstr ""
 "```shell\n"
@@ -16726,30 +15622,27 @@ msgid "You can now build, push, and run the binary:"
 msgstr "그런 다음, 이 바이너리를 빌드하고, 가상 디바이스에 넣고, 실행합니다:"
 
 #: src/android/build-rules/binary.md:29
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ m hello_rust\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust /data/local/tmp\n"
-"$ adb shell /data/local/tmp/hello_rust\n"
-"Hello from Rust!\n"
+"m hello_rust\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust /data/local/tmp\"\n"
+"adb shell /data/local/tmp/hello_rust\n"
 "```"
 msgstr ""
+"```shell\n"
+"$ m hello_rust_logs\n"
+"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/"
+"tmp\"\n"
+"$ adb shell /data/local/tmp/hello_rust_logs\n"
+"```"
 
-#: src/android/build-rules/binary.md:29
+#: src/android/build-rules/binary.md:35
 msgid ""
-"```shell\n"
-"$ m hello_rust\n"
-"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust /data/local/tmp\"\n"
-"$ adb shell /data/local/tmp/hello_rust\n"
+"```text\n"
 "Hello from Rust!\n"
 "```"
 msgstr ""
-"```shell\n"
-"$ m hello_rust\n"
-"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust /data/local/tmp\"\n"
-"$ adb shell /data/local/tmp/hello_rust\n"
-"Hello from Rust!\n"
-"```"
 
 #: src/android/build-rules/library.md:1
 msgid "Rust Libraries"
@@ -16872,26 +15765,13 @@ msgid "You build, push, and run the binary like before:"
 msgstr "이전처럼, 빌드하고, 가상 디바이스로 넣고, 실행합니다:"
 
 #: src/android/build-rules/library.md:61
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ m hello_rust_with_dep\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep /data/local/"
-"tmp\n"
-"$ adb shell /data/local/tmp/hello_rust_with_dep\n"
-"Hello Bob, it is very\n"
-"nice to meet you!\n"
-"```"
-msgstr ""
-
-#: src/android/build-rules/library.md:61
-msgid ""
-"```shell\n"
-"$ m hello_rust_with_dep\n"
-"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep /data/local/"
+"m hello_rust_with_dep\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep /data/local/"
 "tmp\"\n"
-"$ adb shell /data/local/tmp/hello_rust_with_dep\n"
-"Hello Bob, it is very\n"
-"nice to meet you!\n"
+"adb shell /data/local/tmp/hello_rust_with_dep\n"
 "```"
 msgstr ""
 "```shell\n"
@@ -16903,21 +15783,13 @@ msgstr ""
 "nice to meet you!\n"
 "```"
 
-#: src/android/logging.md:44
+#: src/android/build-rules/library.md:67
 msgid ""
-"```shell\n"
-"$ m hello_rust_logs\n"
-"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/"
-"tmp\"\n"
-"$ adb shell /data/local/tmp/hello_rust_logs\n"
+"```text\n"
+"Hello Bob, it is very\n"
+"nice to meet you!\n"
 "```"
 msgstr ""
-"```shell\n"
-"$ m hello_rust_logs\n"
-"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/"
-"tmp\"\n"
-"$ adb shell /data/local/tmp/hello_rust_logs\n"
-"```"
 
 #: src/android/aidl.md:3
 msgid ""
@@ -17195,21 +16067,13 @@ msgid "We can now build, push, and start the service:"
 msgstr "서비스를 빌드하고, 가상 디바이스에 넣고, 시작 할 수 있습니다:"
 
 #: src/android/aidl/deploy.md:5
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ m birthday_server\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/tmp\n"
-"$ adb shell /data/local/tmp/birthday_server\n"
-"```"
-msgstr ""
-
-#: src/android/aidl/deploy.md:5
-msgid ""
-"```shell\n"
-"$ m birthday_server\n"
-"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/"
+"m birthday_server\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/"
 "tmp\"\n"
-"$ adb shell /data/local/tmp/birthday_server\n"
+"adb shell /data/local/tmp/birthday_server\n"
 "```"
 msgstr ""
 "```shell\n"
@@ -17224,25 +16088,49 @@ msgid "In another terminal, check that the service runs:"
 msgstr "다른 터미널을 띄워서 서비스가 잘 수행되고 있는지 확인합니다:"
 
 #: src/android/aidl/deploy.md:13
+#, fuzzy
 msgid ""
 "```shell\n"
+"adb shell service check birthdayservice\n"
+"```"
+msgstr ""
+"```shell\n"
 "$ adb shell service check birthdayservice\n"
 "Service birthdayservice: found\n"
 "```"
+
+#: src/android/aidl/deploy.md:17
+#, fuzzy
+msgid ""
+"```text\n"
+"Service birthdayservice: found\n"
+"```"
 msgstr ""
 "```shell\n"
 "$ adb shell service check birthdayservice\n"
 "Service birthdayservice: found\n"
 "```"
 
-#: src/android/aidl/deploy.md:18
+#: src/android/aidl/deploy.md:21
 msgid "You can also call the service with `service call`:"
 msgstr "`service call`명렁어로 서비스를 호출할 수도 있습니다:"
 
-#: src/android/aidl/deploy.md:20
+#: src/android/aidl/deploy.md:23
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ $ adb shell service call birthdayservice 1 s16 Bob i32 24\n"
+"adb shell service call birthdayservice 1 s16 Bob i32 24\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ adb shell service check birthdayservice\n"
+"Service birthdayservice: found\n"
+"```"
+
+#: src/android/aidl/deploy.md:27
+#, fuzzy
+msgid ""
+"```text\n"
 "Result: Parcel(\n"
 "  0x00000000: 00000000 00000036 00610048 00700070 '....6...H.a.p.p.'\n"
 "  0x00000010: 00200079 00690042 00740072 00640068 'y. .B.i.r.t.h.d.'\n"
@@ -17385,32 +16273,28 @@ msgid "Build, push, and run the client on your device:"
 msgstr "빌드하고, 가상 디바이스로 넣고, 실행합니다:"
 
 #: src/android/aidl/client.md:56
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ m birthday_client\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/tmp\n"
-"$ adb shell /data/local/tmp/birthday_client Charlie 60\n"
-"Happy Birthday Charlie, congratulations with the 60 years!\n"
+"m birthday_client\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/"
+"tmp\"\n"
+"adb shell /data/local/tmp/birthday_client Charlie 60\n"
 "```"
 msgstr ""
+"```shell\n"
+"$ m birthday_server\n"
+"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/"
+"tmp\"\n"
+"$ adb shell /data/local/tmp/birthday_server\n"
+"```"
 
-#: src/android/aidl/client.md:56
+#: src/android/aidl/client.md:62
 msgid ""
-"```shell\n"
-"$ m birthday_client\n"
-"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/"
-"tmp\"\n"
-"$ adb shell /data/local/tmp/birthday_client Charlie 60\n"
+"```text\n"
 "Happy Birthday Charlie, congratulations with the 60 years!\n"
 "```"
 msgstr ""
-"```shell\n"
-"$ m birthday_client\n"
-"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/"
-"tmp\"\n"
-"$ adb shell /data/local/tmp/birthday_client Charlie 60\n"
-"Happy Birthday Charlie, congratulations with the 60 years!\n"
-"```"
 
 #: src/android/aidl/changing.md:3
 msgid ""
@@ -17533,22 +16417,41 @@ msgid "Build, push, and run the binary on your device:"
 msgstr "빌드하고, 가상 디바이스에 넣고, 실행합니다:"
 
 #: src/android/logging.md:44
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ m hello_rust_logs\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/tmp\n"
-"$ adb shell /data/local/tmp/hello_rust_logs\n"
+"m hello_rust_logs\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/"
+"tmp\"\n"
+"adb shell /data/local/tmp/hello_rust_logs\n"
 "```"
 msgstr ""
+"```shell\n"
+"$ m hello_rust_logs\n"
+"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/"
+"tmp\"\n"
+"$ adb shell /data/local/tmp/hello_rust_logs\n"
+"```"
 
 #: src/android/logging.md:50
 msgid "The logs show up in `adb logcat`:"
 msgstr "`adb logcat`커맨드로 로그를 확인합니다:"
 
 #: src/android/logging.md:52
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ adb logcat -s rust\n"
+"adb logcat -s rust\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ sudo apt install cargo rust-src rustfmt\n"
+"```"
+
+#: src/android/logging.md:56
+#, fuzzy
+msgid ""
+"```text\n"
 "09-08 08:38:32.454  2420  2420 D rust: hello_rust_logs: Starting program.\n"
 "09-08 08:38:32.454  2420  2420 I rust: hello_rust_logs: Things are going "
 "fine.\n"
@@ -17797,14 +16700,21 @@ msgid ""
 msgstr ""
 
 #: src/android/interoperability/with-c/bindgen.md:100
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ m print_birthday_card\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/print_birthday_card /data/local/"
-"tmp\n"
-"$ adb shell /data/local/tmp/print_birthday_card\n"
+"m print_birthday_card\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/print_birthday_card /data/local/"
+"tmp\"\n"
+"adb shell /data/local/tmp/print_birthday_card\n"
 "```"
 msgstr ""
+"```shell\n"
+"$ m birthday_server\n"
+"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/"
+"tmp\"\n"
+"$ adb shell /data/local/tmp/birthday_server\n"
+"```"
 
 #: src/android/interoperability/with-c/bindgen.md:106
 msgid "Finally, we can run auto-generated tests to ensure the bindings work:"
@@ -17830,7 +16740,7 @@ msgstr ""
 #: src/android/interoperability/with-c/bindgen.md:122
 msgid ""
 "```shell\n"
-"$ atest libbirthday_bindgen_test\n"
+"atest libbirthday_bindgen_test\n"
 "```"
 msgstr ""
 
@@ -17937,13 +16847,21 @@ msgid ""
 msgstr ""
 
 #: src/android/interoperability/with-c/rust.md:75
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ m analyze_numbers\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/analyze_numbers /data/local/tmp\n"
-"$ adb shell /data/local/tmp/analyze_numbers\n"
+"m analyze_numbers\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/analyze_numbers /data/local/"
+"tmp\"\n"
+"adb shell /data/local/tmp/analyze_numbers\n"
 "```"
 msgstr ""
+"```shell\n"
+"$ m birthday_server\n"
+"$ adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/"
+"tmp\"\n"
+"$ adb shell /data/local/tmp/birthday_server\n"
+"```"
 
 #: src/android/interoperability/with-c/rust.md:83
 msgid ""
@@ -17975,6 +16893,42 @@ msgstr ""
 "사용하는 방법에 대해서는[CXX 튜토리얼](https://cxx.rs/tutorial.html) 를 참조"
 "합니다."
 
+#: src/android/interoperability/cpp.md:14
+msgid ""
+"At this point, the instructor should switch to the [CXX tutorial](https://"
+"cxx.rs/tutorial.html)."
+msgstr ""
+
+#: src/android/interoperability/cpp.md:16
+msgid "Walk the students through the tutorial step by step."
+msgstr ""
+
+#: src/android/interoperability/cpp.md:18
+msgid ""
+"Highlight how CXX presents a clean interface without unsafe code in _both "
+"languages_."
+msgstr ""
+
+#: src/android/interoperability/cpp.md:20
+msgid ""
+"Show the correspondence between [Rust and C++ types](https://cxx.rs/bindings."
+"html):"
+msgstr ""
+
+#: src/android/interoperability/cpp.md:22
+msgid ""
+"Explain how a Rust `String` cannot map to a C++ `std::string` (the latter "
+"does not uphold the UTF-8 invariant). Show that despite being different "
+"types, `rust::String` in C++ can be easily constructed from a C++ `std::"
+"string`, making it very ergonomic to use."
+msgstr ""
+
+#: src/android/interoperability/cpp.md:28
+msgid ""
+"Explain that a Rust function returning `Result<T, E>` becomes a function "
+"which throws a `E` exception in C++ (and vice versa)."
+msgstr ""
+
 #: src/android/interoperability/java.md:1
 msgid "Interoperability with Java"
 msgstr "Java와의 상호운용성"
@@ -18131,11 +17085,12 @@ msgid "Finally, you can build, sync, and run the binary:"
 msgstr "마지막으로 바이너리를 빌드, 싱크, 실행합니다:"
 
 #: src/android/interoperability/java.md:75
+#, fuzzy
 msgid ""
 "```shell\n"
-"$ m helloworld_jni\n"
-"$ adb sync  # requires adb root && adb remount\n"
-"$ adb shell /system/bin/helloworld_jni\n"
+"m helloworld_jni\n"
+"adb sync  # requires adb root && adb remount\n"
+"adb shell /system/bin/helloworld_jni\n"
 "```"
 msgstr ""
 "```shell\n"
@@ -18144,23 +17099,24 @@ msgstr ""
 "$ adb shell /system/bin/helloworld_jni\n"
 "```"
 
-#: src/exercises/day-4/android.md:3
+#: src/exercises/android/morning.md:3
+#, fuzzy
 msgid ""
-"For the last exercise, we will look at one of the projects you work with. "
-"Let us group up and do this together. Some suggestions:"
+"This is a group exercise: We will look at one of the projects you work with "
+"and try to integrate some Rust into it. Some suggestions:"
 msgstr ""
 "마지막 연습문제는 여러분이 작업하고 있는 프로젝트 중 하나를 FFI로 러스트와 연"
 "계 해보는 것입니다. 몇 가지 예시입니다:"
 
-#: src/exercises/day-4/android.md:6
+#: src/exercises/android/morning.md:6
 msgid "Call your AIDL service with a client written in Rust."
 msgstr "당신의 AIDL서비스를 러스트 클라이언트에서 호출해봅니다."
 
-#: src/exercises/day-4/android.md:8
+#: src/exercises/android/morning.md:8
 msgid "Move a function from your project to Rust and call it."
 msgstr "당신의 프로젝트의 함수를 러스트로 옮기고 호출해봅니다."
 
-#: src/exercises/day-4/android.md:12
+#: src/exercises/android/morning.md:12
 msgid ""
 "No solution is provided here since this is open-ended: it relies on someone "
 "in the class having a piece of code which you can turn in to Rust on the fly."
@@ -18168,6 +17124,11 @@ msgstr ""
 "이 연습문제는 열려있기 때문에 해답이 제공되지 않습니다. 클래스에서 제출된 코"
 "드에 의존합니다."
 
+#: src/bare-metal.md:1
+#, fuzzy
+msgid "Welcome to Bare Metal Rust"
+msgstr "Welcome to Comprehensive Rust 🦀"
+
 #: src/bare-metal.md:3
 msgid ""
 "This is a standalone one-day course about bare-metal Rust, aimed at people "
@@ -18577,10 +17538,6 @@ msgid "This example will build but not run, as it doesn't have an entry point."
 msgstr ""
 "이 예시 코드는 빌드는 되지만, 진입점이 없기 때문에 실행되지는 않습니다."
 
-#: src/bare-metal/microcontrollers.md:1 src/SUMMARY.md:215
-msgid "Microcontrollers"
-msgstr "마이크로컨트롤러"
-
 #: src/bare-metal/microcontrollers.md:3
 msgid ""
 "The `cortex_m_rt` crate provides (among other things) a reset handler for "
@@ -18644,10 +17601,6 @@ msgstr ""
 msgid "Run the example with `cargo embed --bin minimal`"
 msgstr "`cargo embed --bin minimal`을 사용하여 예시를 실행합니다."
 
-#: src/bare-metal/microcontrollers/mmio.md:1 src/SUMMARY.md:216
-msgid "Raw MMIO"
-msgstr "원시 MMIO"
-
 #: src/bare-metal/microcontrollers/mmio.md:3
 msgid ""
 "Most microcontrollers access peripherals via memory-mapped IO. Let's try "
@@ -19050,6 +18003,11 @@ msgstr ""
 "cargo embed --bin hal\n"
 "```"
 
+#: src/bare-metal/microcontrollers/board-support.md:1
+#, fuzzy
+msgid "Board support crates"
+msgstr "보드 지원 크레이트"
+
 #: src/bare-metal/microcontrollers/board-support.md:3
 msgid ""
 "Board support crates provide a further level of wrapping for a specific "
@@ -19449,6 +18407,11 @@ msgstr ""
 "cargo embed --bin board_support debug\n"
 "```"
 
+#: src/bare-metal/microcontrollers/debugging.md:19
+#, fuzzy
+msgid "In another terminal in the same directory:"
+msgstr "다른 터미널을 띄워서 서비스가 잘 수행되고 있는지 확인합니다:"
+
 #: src/bare-metal/microcontrollers/debugging.md:21
 msgid ""
 "```sh\n"
@@ -19583,6 +18546,201 @@ msgstr ""
 "FreeRTOS는 대부분 C로 작성되지만, 애플리케이션을 Rust로 작성할 수 있도록 해 "
 "주는 Rust 바인딩이 제공됩니다."
 
+#: src/exercises/bare-metal/morning.md:3
+msgid ""
+"We will read the direction from an I2C compass, and log the readings to a "
+"serial port."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:3
+msgid ""
+"We will read the direction from an I2C compass, and log the readings to a "
+"serial port. If you have time, try displaying it on the LEDs somehow too, or "
+"use the buttons somehow."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:6
+msgid "Hints:"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:8
+msgid ""
+"Check the documentation for the [`lsm303agr`](https://docs.rs/lsm303agr/"
+"latest/lsm303agr/) and [`microbit-v2`](https://docs.rs/microbit-v2/latest/"
+"microbit/) crates, as well as the [micro:bit hardware](https://tech.microbit."
+"org/hardware/)."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:11
+msgid ""
+"The LSM303AGR Inertial Measurement Unit is connected to the internal I2C bus."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:12
+msgid ""
+"TWI is another name for I2C, so the I2C master peripheral is called TWIM."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:13
+msgid ""
+"The LSM303AGR driver needs something implementing the `embedded_hal::"
+"blocking::i2c::WriteRead` trait. The [`microbit::hal::Twim`](https://docs.rs/"
+"microbit-v2/latest/microbit/hal/struct.Twim.html) struct implements this."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:17
+msgid ""
+"You have a [`microbit::Board`](https://docs.rs/microbit-v2/latest/microbit/"
+"struct.Board.html) struct with fields for the various pins and peripherals."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:19
+msgid ""
+"You can also look at the [nRF52833 datasheet](https://infocenter.nordicsemi."
+"com/pdf/nRF52833_PS_v1.5.pdf) if you want, but it shouldn't be necessary for "
+"this exercise."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:23
+msgid ""
+"Download the [exercise template](../../comprehensive-rust-exercises.zip) and "
+"look in the `compass` directory for the following files."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:26 src/exercises/bare-metal/rtc.md:19
+#, fuzzy
+msgid "`src/main.rs`:"
+msgstr "_hello_rust/src/main.rs_:"
+
+#: src/exercises/bare-metal/compass.md:30
+msgid ""
+"```rust,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"extern crate panic_halt as _;\n"
+"\n"
+"use core::fmt::Write;\n"
+"use cortex_m_rt::entry;\n"
+"use microbit::{hal::uarte::{Baudrate, Parity, Uarte}, Board};\n"
+"\n"
+"#[entry]\n"
+"fn main() -> ! {\n"
+"    let board = Board::take().unwrap();\n"
+"\n"
+"    // Configure serial port.\n"
+"    let mut serial = Uarte::new(\n"
+"        board.UARTE0,\n"
+"        board.uart.into(),\n"
+"        Parity::EXCLUDED,\n"
+"        Baudrate::BAUD115200,\n"
+"    );\n"
+"\n"
+"    // Set up the I2C controller and Inertial Measurement Unit.\n"
+"    // TODO\n"
+"\n"
+"    writeln!(serial, \"Ready.\").unwrap();\n"
+"\n"
+"    loop {\n"
+"        // Read compass data and log it to the serial port.\n"
+"        // TODO\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:64 src/exercises/bare-metal/rtc.md:385
+msgid "`Cargo.toml` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:68
+msgid ""
+"```toml\n"
+"[workspace]\n"
+"\n"
+"[package]\n"
+"name = \"compass\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"publish = false\n"
+"\n"
+"[dependencies]\n"
+"cortex-m-rt = \"0.7.3\"\n"
+"embedded-hal = \"0.2.6\"\n"
+"lsm303agr = \"0.2.2\"\n"
+"microbit-v2 = \"0.13.0\"\n"
+"panic-halt = \"0.2.0\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:85
+msgid "`Embed.toml` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:89
+#, fuzzy
+msgid ""
+"```toml\n"
+"[default.general]\n"
+"chip = \"nrf52833_xxAA\"\n"
+"\n"
+"[debug.gdb]\n"
+"enabled = true\n"
+"\n"
+"[debug.reset]\n"
+"halt_afterwards = true\n"
+"```"
+msgstr ""
+"```toml\n"
+"[default.general]\n"
+"chip = \"nrf52833_xxAA\"\n"
+"\n"
+"[debug.gdb]\n"
+"enabled = true\n"
+"```"
+
+#: src/exercises/bare-metal/compass.md:100 src/exercises/bare-metal/rtc.md:985
+msgid "`.cargo/config.toml` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:104
+msgid ""
+"```toml\n"
+"[build]\n"
+"target = \"thumbv7em-none-eabihf\" # Cortex-M4F\n"
+"\n"
+"[target.'cfg(all(target_arch = \"arm\", target_os = \"none\"))']\n"
+"rustflags = [\"-C\", \"link-arg=-Tlink.x\"]\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:112
+msgid "See the serial output on Linux with:"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:114
+msgid ""
+"```sh\n"
+"picocom --baud 115200 --imap lfcrlf /dev/ttyACM0\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:118
+msgid ""
+"Or on Mac OS something like (the device name may be slightly different):"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:120
+msgid ""
+"```sh\n"
+"picocom --baud 115200 --imap lfcrlf /dev/tty.usbmodem14502\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:124
+msgid "Use Ctrl+A Ctrl+Q to quit picocom."
+msgstr ""
+
 #: src/bare-metal/aps.md:1
 msgid "Application processors"
 msgstr "애플리케이션 프로세서"
@@ -19619,6 +18777,154 @@ msgstr ""
 "'virt' 보드는 특정 실제 하드웨어를 에뮬레이션 하지 않으며, 가상 머신용으로만 "
 "설계되었습니다."
 
+#: src/bare-metal/aps/entry-point.md:3
+msgid ""
+"Before we can start running Rust code, we need to do some initialisation."
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:5
+msgid ""
+"```armasm\n"
+".section .init.entry, \"ax\"\n"
+".global entry\n"
+"entry:\n"
+"    /*\n"
+"     * Load and apply the memory management configuration, ready to enable "
+"MMU and\n"
+"     * caches.\n"
+"     */\n"
+"    adrp x30, idmap\n"
+"    msr ttbr0_el1, x30\n"
+"\n"
+"    mov_i x30, .Lmairval\n"
+"    msr mair_el1, x30\n"
+"\n"
+"    mov_i x30, .Ltcrval\n"
+"    /* Copy the supported PA range into TCR_EL1.IPS. */\n"
+"    mrs x29, id_aa64mmfr0_el1\n"
+"    bfi x30, x29, #32, #4\n"
+"\n"
+"    msr tcr_el1, x30\n"
+"\n"
+"    mov_i x30, .Lsctlrval\n"
+"\n"
+"    /*\n"
+"     * Ensure everything before this point has completed, then invalidate "
+"any\n"
+"     * potentially stale local TLB entries before they start being used.\n"
+"     */\n"
+"    isb\n"
+"    tlbi vmalle1\n"
+"    ic iallu\n"
+"    dsb nsh\n"
+"    isb\n"
+"\n"
+"    /*\n"
+"     * Configure sctlr_el1 to enable MMU and cache and don't proceed until "
+"this\n"
+"     * has completed.\n"
+"     */\n"
+"    msr sctlr_el1, x30\n"
+"    isb\n"
+"\n"
+"    /* Disable trapping floating point access in EL1. */\n"
+"    mrs x30, cpacr_el1\n"
+"    orr x30, x30, #(0x3 << 20)\n"
+"    msr cpacr_el1, x30\n"
+"    isb\n"
+"\n"
+"    /* Zero out the bss section. */\n"
+"    adr_l x29, bss_begin\n"
+"    adr_l x30, bss_end\n"
+"0:  cmp x29, x30\n"
+"    b.hs 1f\n"
+"    stp xzr, xzr, [x29], #16\n"
+"    b 0b\n"
+"\n"
+"1:  /* Prepare the stack. */\n"
+"    adr_l x30, boot_stack_end\n"
+"    mov sp, x30\n"
+"\n"
+"    /* Set up exception vector. */\n"
+"    adr x30, vector_table_el1\n"
+"    msr vbar_el1, x30\n"
+"\n"
+"    /* Call into Rust code. */\n"
+"    bl main\n"
+"\n"
+"    /* Loop forever waiting for interrupts. */\n"
+"2:  wfi\n"
+"    b 2b\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:77
+msgid ""
+"This is the same as it would be for C: initialising the processor state, "
+"zeroing the BSS, and setting up the stack pointer."
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:79
+msgid ""
+"The BSS (block starting symbol, for historical reasons) is the part of the "
+"object file which containing statically allocated variables which are "
+"initialised to zero. They are omitted from the image, to avoid wasting space "
+"on zeroes. The compiler assumes that the loader will take care of zeroing "
+"them."
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:83
+msgid ""
+"The BSS may already be zeroed, depending on how memory is initialised and "
+"the image is loaded, but we zero it to be sure."
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:85
+msgid ""
+"We need to enable the MMU and cache before reading or writing any memory. If "
+"we don't:"
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:86
+msgid ""
+"Unaligned accesses will fault. We build the Rust code for the `aarch64-"
+"unknown-none` target which sets `+strict-align` to prevent the compiler "
+"generating unaligned accesses, so it should be fine in this case, but this "
+"is not necessarily the case in general."
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:89
+msgid ""
+"If it were running in a VM, this can lead to cache coherency issues. The "
+"problem is that the VM is accessing memory directly with the cache disabled, "
+"while the host has cachable aliases to the same memory. Even if the host "
+"doesn't explicitly access the memory, speculative accesses can lead to cache "
+"fills, and then changes from one or the other will get lost when the cache "
+"is cleaned or the VM enables the cache. (Cache is keyed by physical address, "
+"not VA or IPA.)"
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:94
+msgid ""
+"For simplicity, we just use a hardcoded pagetable (see `idmap.S`) which "
+"identity maps the first 1 GiB of address space for devices, the next 1 GiB "
+"for DRAM, and another 1 GiB higher up for more devices. This matches the "
+"memory layout that QEMU uses."
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:97
+msgid ""
+"We also set up the exception vector (`vbar_el1`), which we'll see more about "
+"later."
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:98
+msgid ""
+"All examples this afternoon assume we will be running at exception level 1 "
+"(EL1). If you need to run at a different exception level you'll need to "
+"modify `entry.S` accordingly."
+msgstr ""
+
 #: src/bare-metal/aps/inline-assembly.md:1
 msgid "Inline assembly"
 msgstr "인라인 어셈블리"
@@ -19976,6 +19282,49 @@ msgstr ""
 "이는 안전하지 않은 코드의 안전한 래퍼를 작성하는 일반적인 패턴입니다. 안전에 "
 "관한 증명 부담을 여러 많은 위치에서 소수의 위치로 옮기는 것입니다."
 
+#: src/bare-metal/aps/uart/traits.md:1
+#, fuzzy
+msgid "More traits"
+msgstr "트레잇(Trait)"
+
+#: src/bare-metal/aps/uart/traits.md:3
+msgid ""
+"We derived the `Debug` trait. It would be useful to implement a few more "
+"traits too."
+msgstr ""
+
+#: src/bare-metal/aps/uart/traits.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use core::fmt::{self, Write};\n"
+"\n"
+"impl Write for Uart {\n"
+"    fn write_str(&mut self, s: &str) -> fmt::Result {\n"
+"        for c in s.as_bytes() {\n"
+"            self.write_byte(*c);\n"
+"        }\n"
+"        Ok(())\n"
+"    }\n"
+"}\n"
+"\n"
+"// Safe because it just contains a pointer to device memory, which can be\n"
+"// accessed from any context.\n"
+"unsafe impl Send for Uart {}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/uart/traits.md:24
+msgid ""
+"Implementing `Write` lets us use the `write!` and `writeln!` macros with our "
+"`Uart` type."
+msgstr ""
+
+#: src/bare-metal/aps/uart/traits.md:25
+msgid ""
+"Run the example in QEMU with `make qemu_minimal` under `src/bare-metal/aps/"
+"examples`."
+msgstr ""
+
 #: src/bare-metal/aps/better-uart.md:1
 msgid "A better UART driver"
 msgstr "더 나은 UART 드라이버"
@@ -20155,6 +19504,306 @@ msgstr "3"
 msgid "There are also some ID registers which have been omitted for brevity."
 msgstr "간결성을 위해 일부 ID 레지스터는 생략되었습니다."
 
+#: src/bare-metal/aps/better-uart/bitflags.md:3
+msgid ""
+"The [`bitflags`](https://crates.io/crates/bitflags) crate is useful for "
+"working with bitflags."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/bitflags.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use bitflags::bitflags;\n"
+"\n"
+"bitflags! {\n"
+"    /// Flags from the UART flag register.\n"
+"    #[repr(transparent)]\n"
+"    #[derive(Copy, Clone, Debug, Eq, PartialEq)]\n"
+"    struct Flags: u16 {\n"
+"        /// Clear to send.\n"
+"        const CTS = 1 << 0;\n"
+"        /// Data set ready.\n"
+"        const DSR = 1 << 1;\n"
+"        /// Data carrier detect.\n"
+"        const DCD = 1 << 2;\n"
+"        /// UART busy transmitting data.\n"
+"        const BUSY = 1 << 3;\n"
+"        /// Receive FIFO is empty.\n"
+"        const RXFE = 1 << 4;\n"
+"        /// Transmit FIFO is full.\n"
+"        const TXFF = 1 << 5;\n"
+"        /// Receive FIFO is full.\n"
+"        const RXFF = 1 << 6;\n"
+"        /// Transmit FIFO is empty.\n"
+"        const TXFE = 1 << 7;\n"
+"        /// Ring indicator.\n"
+"        const RI = 1 << 8;\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/bitflags.md:37
+msgid ""
+"The `bitflags!` macro creates a newtype something like `Flags(u16)`, along "
+"with a bunch of method implementations to get and set flags."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/registers.md:1
+#, fuzzy
+msgid "Multiple registers"
+msgstr "더 많은 레지스터"
+
+#: src/bare-metal/aps/better-uart/registers.md:3
+msgid ""
+"We can use a struct to represent the memory layout of the UART's registers."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/registers.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"#[repr(C, align(4))]\n"
+"struct Registers {\n"
+"    dr: u16,\n"
+"    _reserved0: [u8; 2],\n"
+"    rsr: ReceiveStatus,\n"
+"    _reserved1: [u8; 19],\n"
+"    fr: Flags,\n"
+"    _reserved2: [u8; 6],\n"
+"    ilpr: u8,\n"
+"    _reserved3: [u8; 3],\n"
+"    ibrd: u16,\n"
+"    _reserved4: [u8; 2],\n"
+"    fbrd: u8,\n"
+"    _reserved5: [u8; 3],\n"
+"    lcr_h: u8,\n"
+"    _reserved6: [u8; 3],\n"
+"    cr: u16,\n"
+"    _reserved7: [u8; 3],\n"
+"    ifls: u8,\n"
+"    _reserved8: [u8; 3],\n"
+"    imsc: u16,\n"
+"    _reserved9: [u8; 2],\n"
+"    ris: u16,\n"
+"    _reserved10: [u8; 2],\n"
+"    mis: u16,\n"
+"    _reserved11: [u8; 2],\n"
+"    icr: u16,\n"
+"    _reserved12: [u8; 2],\n"
+"    dmacr: u8,\n"
+"    _reserved13: [u8; 3],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/registers.md:41
+msgid ""
+"[`#[repr(C)]`](https://doc.rust-lang.org/reference/type-layout.html#the-c-"
+"representation) tells the compiler to lay the struct fields out in order, "
+"following the same rules as C. This is necessary for our struct to have a "
+"predictable layout, as default Rust representation allows the compiler to "
+"(among other things) reorder fields however it sees fit."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/driver.md:3
+msgid "Now let's use the new `Registers` struct in our driver."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/driver.md:5
+#, fuzzy
+msgid ""
+"```rust,editable,compile_fail\n"
+"/// Driver for a PL011 UART.\n"
+"#[derive(Debug)]\n"
+"pub struct Uart {\n"
+"    registers: *mut Registers,\n"
+"}\n"
+"\n"
+"impl Uart {\n"
+"    /// Constructs a new instance of the UART driver for a PL011 device at "
+"the\n"
+"    /// given base address.\n"
+"    ///\n"
+"    /// # Safety\n"
+"    ///\n"
+"    /// The given base address must point to the 8 MMIO control registers of "
+"a\n"
+"    /// PL011 device, which must be mapped into the address space of the "
+"process\n"
+"    /// as device memory and not have any other aliases.\n"
+"    pub unsafe fn new(base_address: *mut u32) -> Self {\n"
+"        Self {\n"
+"            registers: base_address as *mut Registers,\n"
+"        }\n"
+"    }\n"
+"\n"
+"    /// Writes a single byte to the UART.\n"
+"    pub fn write_byte(&self, byte: u8) {\n"
+"        // Wait until there is room in the TX buffer.\n"
+"        while self.read_flag_register().contains(Flags::TXFF) {}\n"
+"\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL011 device which is appropriately mapped.\n"
+"        unsafe {\n"
+"            // Write to the TX buffer.\n"
+"            addr_of_mut!((*self.registers).dr).write_volatile(byte.into());\n"
+"        }\n"
+"\n"
+"        // Wait until the UART is no longer busy.\n"
+"        while self.read_flag_register().contains(Flags::BUSY) {}\n"
+"    }\n"
+"\n"
+"    /// Reads and returns a pending byte, or `None` if nothing has been "
+"received.\n"
+"    pub fn read_byte(&self) -> Option<u8> {\n"
+"        if self.read_flag_register().contains(Flags::RXFE) {\n"
+"            None\n"
+"        } else {\n"
+"            let data = unsafe { addr_of!((*self.registers).dr)."
+"read_volatile() };\n"
+"            // TODO: Check for error conditions in bits 8-11.\n"
+"            Some(data as u8)\n"
+"        }\n"
+"    }\n"
+"\n"
+"    fn read_flag_register(&self) -> Flags {\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL011 device which is appropriately mapped.\n"
+"        unsafe { addr_of!((*self.registers).fr).read_volatile() }\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"const FLAG_REGISTER_OFFSET: usize = 0x18;\n"
+"const FR_BUSY: u8 = 1 << 3;\n"
+"const FR_TXFF: u8 = 1 << 5;\n"
+"\n"
+"/// PL011 UART용 최소 드라이버입니다.\n"
+"#[derive(Debug)]\n"
+"pub struct Uart {\n"
+"    base_address: *mut u8,\n"
+"}\n"
+"\n"
+"impl Uart {\n"
+"    /// Constructs a new instance of the UART driver for a PL011 device at "
+"the\n"
+"    /// given base address.\n"
+"    ///\n"
+"    /// # Safety\n"
+"    ///\n"
+"    /// The given base address must point to the 8 MMIO control registers of "
+"a\n"
+"    /// PL011 device, which must be mapped into the address space of the "
+"process\n"
+"    /// as device memory and not have any other aliases.\n"
+"    pub unsafe fn new(base_address: *mut u8) -> Self {\n"
+"        Self { base_address }\n"
+"    }\n"
+"\n"
+"    /// UART에 한 바이트를 씁니다.\n"
+"    pub fn write_byte(&self, byte: u8) {\n"
+"        // Wait until there is room in the TX buffer.\n"
+"        while self.read_flag_register() & FR_TXFF != 0 {}\n"
+"\n"
+"        //  `base_address`가 PL011의 컨트롤 레지스터가 매핑된 주소를 가리키"
+"고\n"
+"        // 있으므로 안전합니다.\n"
+"        unsafe {\n"
+"            // Write to the TX buffer.\n"
+"            self.base_address.write_volatile(byte);\n"
+"        }\n"
+"\n"
+"        // UART가 더 이상 사용 중이 아닐 때까지 기다립니다.\n"
+"        while self.read_flag_register() & FR_BUSY != 0 {}\n"
+"    }\n"
+"\n"
+"    fn read_flag_register(&self) -> u8 {\n"
+"        // Safe because we know that the base address points to the control\n"
+"        // registers of a PL011 device which is appropriately mapped.\n"
+"        unsafe { self.base_address.add(FLAG_REGISTER_OFFSET)."
+"read_volatile() }\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/bare-metal/aps/better-uart/driver.md:64
+msgid ""
+"Note the use of `addr_of!` / `addr_of_mut!` to get pointers to individual "
+"fields without creating an intermediate reference, which would be unsound."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/using.md:1
+#: src/bare-metal/aps/logging/using.md:1
+#, fuzzy
+msgid "Using it"
+msgstr "Bindgen 사용하기"
+
+#: src/bare-metal/aps/better-uart/using.md:3
+msgid ""
+"Let's write a small program using our driver to write to the serial console, "
+"and echo incoming bytes."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/using.md:6
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"mod exceptions;\n"
+"mod pl011;\n"
+"\n"
+"use crate::pl011::Uart;\n"
+"use core::fmt::Write;\n"
+"use core::panic::PanicInfo;\n"
+"use log::error;\n"
+"use smccc::psci::system_off;\n"
+"use smccc::Hvc;\n"
+"\n"
+"/// Base address of the primary PL011 UART.\n"
+"const PL011_BASE_ADDRESS: *mut u32 = 0x900_0000 as _;\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn main(x0: u64, x1: u64, x2: u64, x3: u64) {\n"
+"    // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 "
+"device,\n"
+"    // and nothing else accesses that address range.\n"
+"    let mut uart = unsafe { Uart::new(PL011_BASE_ADDRESS) };\n"
+"\n"
+"    writeln!(uart, \"main({x0:#x}, {x1:#x}, {x2:#x}, {x3:#x})\").unwrap();\n"
+"\n"
+"    loop {\n"
+"        if let Some(byte) = uart.read_byte() {\n"
+"            uart.write_byte(byte);\n"
+"            match byte {\n"
+"                b'\\r' => {\n"
+"                    uart.write_byte(b'\\n');\n"
+"                }\n"
+"                b'q' => break,\n"
+"                _ => {}\n"
+"            }\n"
+"        }\n"
+"    }\n"
+"\n"
+"    writeln!(uart, \"Bye!\").unwrap();\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/using.md:51
+msgid ""
+"As in the [inline assembly](../inline-assembly.md) example, this `main` "
+"function is called from our entry point code in `entry.S`. See the speaker "
+"notes there for details."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/using.md:53
+msgid ""
+"Run the example in QEMU with `make qemu` under `src/bare-metal/aps/examples`."
+msgstr ""
+
 #: src/bare-metal/aps/logging.md:3
 msgid ""
 "It would be nice to be able to use the logging macros from the [`log`]"
@@ -20260,23 +19909,177 @@ msgstr ""
 "`log`함수 안에서 `unwrap`하는 것은 괜찮습니다.. 왜냐하면  `set_logger`를 호출"
 "하기 전에 `LOGGER`를 초기화하기 때문입니다."
 
+#: src/bare-metal/aps/logging/using.md:3
+msgid "We need to initialise the logger before we use it."
+msgstr ""
+
+#: src/bare-metal/aps/logging/using.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"mod exceptions;\n"
+"mod logger;\n"
+"mod pl011;\n"
+"\n"
+"use crate::pl011::Uart;\n"
+"use core::panic::PanicInfo;\n"
+"use log::{error, info, LevelFilter};\n"
+"use smccc::psci::system_off;\n"
+"use smccc::Hvc;\n"
+"\n"
+"/// Base address of the primary PL011 UART.\n"
+"const PL011_BASE_ADDRESS: *mut u32 = 0x900_0000 as _;\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn main(x0: u64, x1: u64, x2: u64, x3: u64) {\n"
+"    // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 "
+"device,\n"
+"    // and nothing else accesses that address range.\n"
+"    let uart = unsafe { Uart::new(PL011_BASE_ADDRESS) };\n"
+"    logger::init(uart, LevelFilter::Trace).unwrap();\n"
+"\n"
+"    info!(\"main({x0:#x}, {x1:#x}, {x2:#x}, {x3:#x})\");\n"
+"\n"
+"    assert_eq!(x1, 42);\n"
+"\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[panic_handler]\n"
+"fn panic(info: &PanicInfo) -> ! {\n"
+"    error!(\"{info}\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"    loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/logging/using.md:46
+msgid "Note that our panic handler can now log details of panics."
+msgstr ""
+
+#: src/bare-metal/aps/logging/using.md:47
+msgid ""
+"Run the example in QEMU with `make qemu_logger` under `src/bare-metal/aps/"
+"examples`."
+msgstr ""
+
+#: src/bare-metal/aps/exceptions.md:3
+msgid ""
+"AArch64 defines an exception vector table with 16 entries, for 4 types of "
+"exceptions (synchronous, IRQ, FIQ, SError) from 4 states (current EL with "
+"SP0, current EL with SPx, lower EL using AArch64, lower EL using AArch32). "
+"We implement this in assembly to save volatile registers to the stack before "
+"calling into Rust code:"
+msgstr ""
+
+#: src/bare-metal/aps/exceptions.md:8
+msgid ""
+"```rust,editable,compile_fail\n"
+"use log::error;\n"
+"use smccc::psci::system_off;\n"
+"use smccc::Hvc;\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn sync_exception_current(_elr: u64, _spsr: u64) {\n"
+"    error!(\"sync_exception_current\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn irq_current(_elr: u64, _spsr: u64) {\n"
+"    error!(\"irq_current\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn fiq_current(_elr: u64, _spsr: u64) {\n"
+"    error!(\"fiq_current\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn serr_current(_elr: u64, _spsr: u64) {\n"
+"    error!(\"serr_current\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn sync_lower(_elr: u64, _spsr: u64) {\n"
+"    error!(\"sync_lower\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn irq_lower(_elr: u64, _spsr: u64) {\n"
+"    error!(\"irq_lower\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn fiq_lower(_elr: u64, _spsr: u64) {\n"
+"    error!(\"fiq_lower\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn serr_lower(_elr: u64, _spsr: u64) {\n"
+"    error!(\"serr_lower\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/exceptions.md:64
+msgid "EL is exception level; all our examples this afternoon run in EL1."
+msgstr ""
+
+#: src/bare-metal/aps/exceptions.md:65
+msgid ""
+"For simplicity we aren't distinguishing between SP0 and SPx for the current "
+"EL exceptions, or between AArch32 and AArch64 for the lower EL exceptions."
+msgstr ""
+
+#: src/bare-metal/aps/exceptions.md:67
+msgid ""
+"For this example we just log the exception and power down, as we don't "
+"expect any of them to actually happen."
+msgstr ""
+
+#: src/bare-metal/aps/exceptions.md:69
+msgid ""
+"We can think of exception handlers and our main execution context more or "
+"less like different threads. [`Send` and `Sync`](../../concurrency/send-sync."
+"md) will control what we can share between them, just like with threads. For "
+"example, if we want to share some value between exception handlers and the "
+"rest of the program, and it's `Send` but not `Sync`, then we'll need to wrap "
+"it in something like a `Mutex` and put it in a static."
+msgstr ""
+
 #: src/bare-metal/aps/other-projects.md:3
+#, fuzzy
 msgid "[oreboot](https://github.com/oreboot/oreboot)"
 msgstr "[oreboot](https://github.com/oreboot/oreboot)"
 
 #: src/bare-metal/aps/other-projects.md:4
+#, fuzzy
 msgid "\"coreboot without the C\""
 msgstr "\"C가 없는 coreboot\""
 
 #: src/bare-metal/aps/other-projects.md:5
+#, fuzzy
 msgid "Supports x86, aarch64 and RISC-V."
 msgstr "x86, aarch64, RISC-V를 지원합니다."
 
 #: src/bare-metal/aps/other-projects.md:6
+#, fuzzy
 msgid "Relies on LinuxBoot rather than having many drivers itself."
 msgstr "자체적으로 여러 드라이버를 보유하는 대신 LinuxBoot에 의존합니다."
 
 #: src/bare-metal/aps/other-projects.md:7
+#, fuzzy
 msgid ""
 "[Rust RaspberryPi OS tutorial](https://github.com/rust-embedded/rust-"
 "raspberrypi-OS-tutorials)"
@@ -20285,6 +20088,7 @@ msgstr ""
 "raspberrypi-OS-tutorials)"
 
 #: src/bare-metal/aps/other-projects.md:8
+#, fuzzy
 msgid ""
 "Initialisation, UART driver, simple bootloader, JTAG, exception levels, "
 "exception handling, page tables"
@@ -20292,21 +20096,47 @@ msgstr ""
 "초기화, UART 드라이버, 간단한 부트로더, JTAG, 예외 수준, 예외 처리, 페이지 테"
 "이블"
 
-#: src/bare-metal/aps/other-projects.md:9
-msgid "Not all very well written, so beware."
+#: src/bare-metal/aps/other-projects.md:10
+#, fuzzy
+msgid ""
+"Some dodginess around cache maintenance and initialisation in Rust, not "
+"necessarily a good example to copy for production code."
 msgstr "잘 작성되지 않은 것도 있으므로 주의하세요."
 
-#: src/bare-metal/aps/other-projects.md:10
+#: src/bare-metal/aps/other-projects.md:12
+#, fuzzy
 msgid "[`cargo-call-stack`](https://crates.io/crates/cargo-call-stack)"
 msgstr "[`cargo-call-stack`](https://crates.io/crates/cargo-call-stack)"
 
-#: src/bare-metal/aps/other-projects.md:11
+#: src/bare-metal/aps/other-projects.md:13
+#, fuzzy
 msgid "Static analysis to determine maximum stack usage."
 msgstr "최대 스택 사용량을 결정하는 정적 분석"
 
-#: src/bare-metal/useful-crates.md:1 src/SUMMARY.md:168
-msgid "Useful crates"
-msgstr "유용한 크레이트"
+#: src/bare-metal/aps/other-projects.md:17
+msgid ""
+"The RaspberryPi OS tutorial runs Rust code before the MMU and caches are "
+"enabled. This will read and write memory (e.g. the stack). However:"
+msgstr ""
+
+#: src/bare-metal/aps/other-projects.md:19
+msgid ""
+"Without the MMU and cache, unaligned accesses will fault. It builds with "
+"`aarch64-unknown-none` which sets `+strict-align` to prevent the compiler "
+"generating unaligned accesses so it should be alright, but this is not "
+"necessarily the case in general."
+msgstr ""
+
+#: src/bare-metal/aps/other-projects.md:22
+msgid ""
+"If it were running in a VM, this can lead to cache coherency issues. The "
+"problem is that the VM is accessing memory directly with the cache disabled, "
+"while the host has cachable aliases to the same memory. Even if the host "
+"doesn't explicitly access the memory, speculative accesses can lead to cache "
+"fills, and then changes from one or the other will get lost. Again this is "
+"alright in this particular case (running directly on the hardware with no "
+"hypervisor), but isn't a good pattern in general."
+msgstr ""
 
 #: src/bare-metal/useful-crates.md:3
 msgid ""
@@ -20658,6 +20488,11 @@ msgstr ""
 "Rust 플레이그라운드에는 `tinyvec`가 포함되어 있으므로 이 예시는 인라인으로 실"
 "행됩니다."
 
+#: src/bare-metal/useful-crates/spin.md:1
+#, fuzzy
+msgid "`spin`"
+msgstr "회전"
+
 #: src/bare-metal/useful-crates/spin.md:3
 msgid ""
 "`std::sync::Mutex` and the other synchronisation primitives from `std::sync` "
@@ -20825,10 +20660,6 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/bare-metal/android/vmbase.md:1 src/SUMMARY.md:250
-msgid "vmbase"
-msgstr "vmbase"
-
 #: src/bare-metal/android/vmbase.md:3
 msgid ""
 "For VMs running under crosvm on aarch64, the [vmbase](https://android."
@@ -20883,6 +20714,4495 @@ msgstr ""
 "`vmbase`가 제공하는 진입점은 콘솔을 초기화 하며, main 함수가 리턴하면  "
 "PSCI_SYSTEM_OFF 메시지를 PSCI를 통해 보내어서  VM을 종료시킵니다."
 
+#: src/exercises/bare-metal/afternoon.md:3
+msgid "We will write a driver for the PL031 real-time clock device."
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:1
+#: src/exercises/bare-metal/solutions-afternoon.md:3
+#, fuzzy
+msgid "RTC driver"
+msgstr "RTC 드라이버"
+
+#: src/exercises/bare-metal/rtc.md:3
+#, fuzzy
+msgid ""
+"The QEMU aarch64 virt machine has a [PL031](https://developer.arm.com/"
+"documentation/ddi0224/c) real-time clock at 0x9010000. For this exercise, "
+"you should write a driver for it."
+msgstr ""
+"QEMU의 'virt' 보드에는 [PL011](https://developer.arm.com/documentation/"
+"ddi0224/c) UART가 있으므로 이를 위한 드라이버를 작성해 보겠습니다."
+
+#: src/exercises/bare-metal/rtc.md:6
+msgid ""
+"Use it to print the current time to the serial console. You can use the "
+"[`chrono`](https://crates.io/crates/chrono) crate for date/time formatting."
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:8
+msgid ""
+"Use the match register and raw interrupt status to busy-wait until a given "
+"time, e.g. 3 seconds in the future. (Call [`core::hint::spin_loop`](https://"
+"doc.rust-lang.org/core/hint/fn.spin_loop.html) inside the loop.)"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:10
+msgid ""
+"_Extension if you have time:_ Enable and handle the interrupt generated by "
+"the RTC match. You can use the driver provided in the [`arm-gic`](https://"
+"docs.rs/arm-gic/) crate to configure the Arm Generic Interrupt Controller."
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:12
+msgid "Use the RTC interrupt, which is wired to the GIC as `IntId::spi(2)`."
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:13
+msgid ""
+"Once the interrupt is enabled, you can put the core to sleep via `arm_gic::"
+"wfi()`, which will cause the core to sleep until it receives an interrupt."
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:16
+msgid ""
+"Download the [exercise template](../../comprehensive-rust-exercises.zip) and "
+"look in the `rtc` directory for the following files."
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:23
+msgid ""
+"```rust,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"mod exceptions;\n"
+"mod logger;\n"
+"mod pl011;\n"
+"\n"
+"use crate::pl011::Uart;\n"
+"use arm_gic::gicv3::GicV3;\n"
+"use core::panic::PanicInfo;\n"
+"use log::{error, info, trace, LevelFilter};\n"
+"use smccc::psci::system_off;\n"
+"use smccc::Hvc;\n"
+"\n"
+"/// Base addresses of the GICv3.\n"
+"const GICD_BASE_ADDRESS: *mut u64 = 0x800_0000 as _;\n"
+"const GICR_BASE_ADDRESS: *mut u64 = 0x80A_0000 as _;\n"
+"\n"
+"/// Base address of the primary PL011 UART.\n"
+"const PL011_BASE_ADDRESS: *mut u32 = 0x900_0000 as _;\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn main(x0: u64, x1: u64, x2: u64, x3: u64) {\n"
+"    // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 "
+"device,\n"
+"    // and nothing else accesses that address range.\n"
+"    let uart = unsafe { Uart::new(PL011_BASE_ADDRESS) };\n"
+"    logger::init(uart, LevelFilter::Trace).unwrap();\n"
+"\n"
+"    info!(\"main({:#x}, {:#x}, {:#x}, {:#x})\", x0, x1, x2, x3);\n"
+"\n"
+"    // Safe because `GICD_BASE_ADDRESS` and `GICR_BASE_ADDRESS` are the "
+"base\n"
+"    // addresses of a GICv3 distributor and redistributor respectively, and\n"
+"    // nothing else accesses those address ranges.\n"
+"    let mut gic = unsafe { GicV3::new(GICD_BASE_ADDRESS, "
+"GICR_BASE_ADDRESS) };\n"
+"    gic.setup();\n"
+"\n"
+"    // TODO: Create instance of RTC driver and print current time.\n"
+"\n"
+"    // TODO: Wait for 3 seconds.\n"
+"\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[panic_handler]\n"
+"fn panic(info: &PanicInfo) -> ! {\n"
+"    error!(\"{info}\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"    loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:75
+msgid ""
+"`src/exceptions.rs` (you should only need to change this for the 3rd part of "
+"the exercise):"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:79
+msgid ""
+"```rust,compile_fail\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"use arm_gic::gicv3::GicV3;\n"
+"use log::{error, info, trace};\n"
+"use smccc::psci::system_off;\n"
+"use smccc::Hvc;\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn sync_exception_current(_elr: u64, _spsr: u64) {\n"
+"    error!(\"sync_exception_current\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn irq_current(_elr: u64, _spsr: u64) {\n"
+"    trace!(\"irq_current\");\n"
+"    let intid = GicV3::get_and_acknowledge_interrupt().expect(\"No pending "
+"interrupt\");\n"
+"    info!(\"IRQ {intid:?}\");\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn fiq_current(_elr: u64, _spsr: u64) {\n"
+"    error!(\"fiq_current\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn serr_current(_elr: u64, _spsr: u64) {\n"
+"    error!(\"serr_current\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn sync_lower(_elr: u64, _spsr: u64) {\n"
+"    error!(\"sync_lower\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn irq_lower(_elr: u64, _spsr: u64) {\n"
+"    error!(\"irq_lower\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn fiq_lower(_elr: u64, _spsr: u64) {\n"
+"    error!(\"fiq_lower\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn serr_lower(_elr: u64, _spsr: u64) {\n"
+"    error!(\"serr_lower\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:149
+msgid "`src/logger.rs` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:153
+#, fuzzy
+msgid ""
+"```rust,compile_fail\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"// ANCHOR: main\n"
+"use crate::pl011::Uart;\n"
+"use core::fmt::Write;\n"
+"use log::{LevelFilter, Log, Metadata, Record, SetLoggerError};\n"
+"use spin::mutex::SpinMutex;\n"
+"\n"
+"static LOGGER: Logger = Logger {\n"
+"    uart: SpinMutex::new(None),\n"
+"};\n"
+"\n"
+"struct Logger {\n"
+"    uart: SpinMutex<Option<Uart>>,\n"
+"}\n"
+"\n"
+"impl Log for Logger {\n"
+"    fn enabled(&self, _metadata: &Metadata) -> bool {\n"
+"        true\n"
+"    }\n"
+"\n"
+"    fn log(&self, record: &Record) {\n"
+"        writeln!(\n"
+"            self.uart.lock().as_mut().unwrap(),\n"
+"            \"[{}] {}\",\n"
+"            record.level(),\n"
+"            record.args()\n"
+"        )\n"
+"        .unwrap();\n"
+"    }\n"
+"\n"
+"    fn flush(&self) {}\n"
+"}\n"
+"\n"
+"/// Initialises UART logger.\n"
+"pub fn init(uart: Uart, max_level: LevelFilter) -> Result<(), "
+"SetLoggerError> {\n"
+"    LOGGER.uart.lock().replace(uart);\n"
+"\n"
+"    log::set_logger(&LOGGER)?;\n"
+"    log::set_max_level(max_level);\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use crate::pl011::Uart;\n"
+"use core::fmt::Write;\n"
+"use log::{LevelFilter, Log, Metadata, Record, SetLoggerError};\n"
+"use spin::mutex::SpinMutex;\n"
+"\n"
+"static LOGGER: Logger = Logger {\n"
+"    uart: SpinMutex::new(None),\n"
+"};\n"
+"\n"
+"struct Logger {\n"
+"    uart: SpinMutex<Option<Uart>>,\n"
+"}\n"
+"\n"
+"impl Log for Logger {\n"
+"    fn enabled(&self, _metadata: &Metadata) -> bool {\n"
+"        true\n"
+"    }\n"
+"\n"
+"    fn log(&self, record: &Record) {\n"
+"        writeln!(\n"
+"            self.uart.lock().as_mut().unwrap(),\n"
+"            \"[{}] {}\",\n"
+"            record.level(),\n"
+"            record.args()\n"
+"        )\n"
+"        .unwrap();\n"
+"    }\n"
+"\n"
+"    fn flush(&self) {}\n"
+"}\n"
+"\n"
+"/// UART 로거를 초기화합니다.\n"
+"pub fn init(uart: Uart, max_level: LevelFilter) -> Result<(), "
+"SetLoggerError> {\n"
+"    LOGGER.uart.lock().replace(uart);\n"
+"\n"
+"    log::set_logger(&LOGGER)?;\n"
+"    log::set_max_level(max_level);\n"
+"    Ok(())\n"
+"}\n"
+"```"
+
+#: src/exercises/bare-metal/rtc.md:210
+msgid "`src/pl011.rs` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:214
+msgid ""
+"```rust,compile_fail\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"#![allow(unused)]\n"
+"\n"
+"use core::fmt::{self, Write};\n"
+"use core::ptr::{addr_of, addr_of_mut};\n"
+"\n"
+"// ANCHOR: Flags\n"
+"use bitflags::bitflags;\n"
+"\n"
+"bitflags! {\n"
+"    /// Flags from the UART flag register.\n"
+"    #[repr(transparent)]\n"
+"    #[derive(Copy, Clone, Debug, Eq, PartialEq)]\n"
+"    struct Flags: u16 {\n"
+"        /// Clear to send.\n"
+"        const CTS = 1 << 0;\n"
+"        /// Data set ready.\n"
+"        const DSR = 1 << 1;\n"
+"        /// Data carrier detect.\n"
+"        const DCD = 1 << 2;\n"
+"        /// UART busy transmitting data.\n"
+"        const BUSY = 1 << 3;\n"
+"        /// Receive FIFO is empty.\n"
+"        const RXFE = 1 << 4;\n"
+"        /// Transmit FIFO is full.\n"
+"        const TXFF = 1 << 5;\n"
+"        /// Receive FIFO is full.\n"
+"        const RXFF = 1 << 6;\n"
+"        /// Transmit FIFO is empty.\n"
+"        const TXFE = 1 << 7;\n"
+"        /// Ring indicator.\n"
+"        const RI = 1 << 8;\n"
+"    }\n"
+"}\n"
+"// ANCHOR_END: Flags\n"
+"\n"
+"bitflags! {\n"
+"    /// Flags from the UART Receive Status Register / Error Clear Register.\n"
+"    #[repr(transparent)]\n"
+"    #[derive(Copy, Clone, Debug, Eq, PartialEq)]\n"
+"    struct ReceiveStatus: u16 {\n"
+"        /// Framing error.\n"
+"        const FE = 1 << 0;\n"
+"        /// Parity error.\n"
+"        const PE = 1 << 1;\n"
+"        /// Break error.\n"
+"        const BE = 1 << 2;\n"
+"        /// Overrun error.\n"
+"        const OE = 1 << 3;\n"
+"    }\n"
+"}\n"
+"\n"
+"// ANCHOR: Registers\n"
+"#[repr(C, align(4))]\n"
+"struct Registers {\n"
+"    dr: u16,\n"
+"    _reserved0: [u8; 2],\n"
+"    rsr: ReceiveStatus,\n"
+"    _reserved1: [u8; 19],\n"
+"    fr: Flags,\n"
+"    _reserved2: [u8; 6],\n"
+"    ilpr: u8,\n"
+"    _reserved3: [u8; 3],\n"
+"    ibrd: u16,\n"
+"    _reserved4: [u8; 2],\n"
+"    fbrd: u8,\n"
+"    _reserved5: [u8; 3],\n"
+"    lcr_h: u8,\n"
+"    _reserved6: [u8; 3],\n"
+"    cr: u16,\n"
+"    _reserved7: [u8; 3],\n"
+"    ifls: u8,\n"
+"    _reserved8: [u8; 3],\n"
+"    imsc: u16,\n"
+"    _reserved9: [u8; 2],\n"
+"    ris: u16,\n"
+"    _reserved10: [u8; 2],\n"
+"    mis: u16,\n"
+"    _reserved11: [u8; 2],\n"
+"    icr: u16,\n"
+"    _reserved12: [u8; 2],\n"
+"    dmacr: u8,\n"
+"    _reserved13: [u8; 3],\n"
+"}\n"
+"// ANCHOR_END: Registers\n"
+"\n"
+"// ANCHOR: Uart\n"
+"/// Driver for a PL011 UART.\n"
+"#[derive(Debug)]\n"
+"pub struct Uart {\n"
+"    registers: *mut Registers,\n"
+"}\n"
+"\n"
+"impl Uart {\n"
+"    /// Constructs a new instance of the UART driver for a PL011 device at "
+"the\n"
+"    /// given base address.\n"
+"    ///\n"
+"    /// # Safety\n"
+"    ///\n"
+"    /// The given base address must point to the MMIO control registers of "
+"a\n"
+"    /// PL011 device, which must be mapped into the address space of the "
+"process\n"
+"    /// as device memory and not have any other aliases.\n"
+"    pub unsafe fn new(base_address: *mut u32) -> Self {\n"
+"        Self {\n"
+"            registers: base_address as *mut Registers,\n"
+"        }\n"
+"    }\n"
+"\n"
+"    /// Writes a single byte to the UART.\n"
+"    pub fn write_byte(&self, byte: u8) {\n"
+"        // Wait until there is room in the TX buffer.\n"
+"        while self.read_flag_register().contains(Flags::TXFF) {}\n"
+"\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL011 device which is appropriately mapped.\n"
+"        unsafe {\n"
+"            // Write to the TX buffer.\n"
+"            addr_of_mut!((*self.registers).dr).write_volatile(byte.into());\n"
+"        }\n"
+"\n"
+"        // Wait until the UART is no longer busy.\n"
+"        while self.read_flag_register().contains(Flags::BUSY) {}\n"
+"    }\n"
+"\n"
+"    /// Reads and returns a pending byte, or `None` if nothing has been "
+"received.\n"
+"    pub fn read_byte(&self) -> Option<u8> {\n"
+"        if self.read_flag_register().contains(Flags::RXFE) {\n"
+"            None\n"
+"        } else {\n"
+"            let data = unsafe { addr_of!((*self.registers).dr)."
+"read_volatile() };\n"
+"            // TODO: Check for error conditions in bits 8-11.\n"
+"            Some(data as u8)\n"
+"        }\n"
+"    }\n"
+"\n"
+"    fn read_flag_register(&self) -> Flags {\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL011 device which is appropriately mapped.\n"
+"        unsafe { addr_of!((*self.registers).fr).read_volatile() }\n"
+"    }\n"
+"}\n"
+"// ANCHOR_END: Uart\n"
+"\n"
+"impl Write for Uart {\n"
+"    fn write_str(&mut self, s: &str) -> fmt::Result {\n"
+"        for c in s.as_bytes() {\n"
+"            self.write_byte(*c);\n"
+"        }\n"
+"        Ok(())\n"
+"    }\n"
+"}\n"
+"\n"
+"// Safe because it just contains a pointer to device memory, which can be\n"
+"// accessed from any context.\n"
+"unsafe impl Send for Uart {}\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:389
+msgid ""
+"```toml\n"
+"[workspace]\n"
+"\n"
+"[package]\n"
+"name = \"rtc\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"publish = false\n"
+"\n"
+"[dependencies]\n"
+"arm-gic = \"0.1.0\"\n"
+"bitflags = \"2.0.0\"\n"
+"chrono = { version = \"0.4.24\", default-features = false }\n"
+"log = \"0.4.17\"\n"
+"smccc = \"0.1.1\"\n"
+"spin = \"0.9.8\"\n"
+"\n"
+"[build-dependencies]\n"
+"cc = \"1.0.73\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:410
+msgid "`build.rs` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:414
+msgid ""
+"```rust,compile_fail\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"use cc::Build;\n"
+"use std::env;\n"
+"\n"
+"fn main() {\n"
+"    #[cfg(target_os = \"linux\")]\n"
+"    env::set_var(\"CROSS_COMPILE\", \"aarch64-linux-gnu\");\n"
+"    #[cfg(not(target_os = \"linux\"))]\n"
+"    env::set_var(\"CROSS_COMPILE\", \"aarch64-none-elf\");\n"
+"\n"
+"    Build::new()\n"
+"        .file(\"entry.S\")\n"
+"        .file(\"exceptions.S\")\n"
+"        .file(\"idmap.S\")\n"
+"        .compile(\"empty\")\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:446
+msgid "`entry.S` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:450
+msgid ""
+"```armasm\n"
+"/*\n"
+" * Copyright 2023 Google LLC\n"
+" *\n"
+" * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+" * you may not use this file except in compliance with the License.\n"
+" * You may obtain a copy of the License at\n"
+" *\n"
+" *     https://www.apache.org/licenses/LICENSE-2.0\n"
+" *\n"
+" * Unless required by applicable law or agreed to in writing, software\n"
+" * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+" * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+" * See the License for the specific language governing permissions and\n"
+" * limitations under the License.\n"
+" */\n"
+"\n"
+".macro adr_l, reg:req, sym:req\n"
+"\tadrp \\reg, \\sym\n"
+"\tadd \\reg, \\reg, :lo12:\\sym\n"
+".endm\n"
+"\n"
+".macro mov_i, reg:req, imm:req\n"
+"\tmovz \\reg, :abs_g3:\\imm\n"
+"\tmovk \\reg, :abs_g2_nc:\\imm\n"
+"\tmovk \\reg, :abs_g1_nc:\\imm\n"
+"\tmovk \\reg, :abs_g0_nc:\\imm\n"
+".endm\n"
+"\n"
+".set .L_MAIR_DEV_nGnRE,\t0x04\n"
+".set .L_MAIR_MEM_WBWA,\t0xff\n"
+".set .Lmairval, .L_MAIR_DEV_nGnRE | (.L_MAIR_MEM_WBWA << 8)\n"
+"\n"
+"/* 4 KiB granule size for TTBR0_EL1. */\n"
+".set .L_TCR_TG0_4KB, 0x0 << 14\n"
+"/* 4 KiB granule size for TTBR1_EL1. */\n"
+".set .L_TCR_TG1_4KB, 0x2 << 30\n"
+"/* Disable translation table walk for TTBR1_EL1, generating a translation "
+"fault instead. */\n"
+".set .L_TCR_EPD1, 0x1 << 23\n"
+"/* Translation table walks for TTBR0_EL1 are inner sharable. */\n"
+".set .L_TCR_SH_INNER, 0x3 << 12\n"
+"/*\n"
+" * Translation table walks for TTBR0_EL1 are outer write-back read-allocate "
+"write-allocate\n"
+" * cacheable.\n"
+" */\n"
+".set .L_TCR_RGN_OWB, 0x1 << 10\n"
+"/*\n"
+" * Translation table walks for TTBR0_EL1 are inner write-back read-allocate "
+"write-allocate\n"
+" * cacheable.\n"
+" */\n"
+".set .L_TCR_RGN_IWB, 0x1 << 8\n"
+"/* Size offset for TTBR0_EL1 is 2**39 bytes (512 GiB). */\n"
+".set .L_TCR_T0SZ_512, 64 - 39\n"
+".set .Ltcrval, .L_TCR_TG0_4KB | .L_TCR_TG1_4KB | .L_TCR_EPD1 | ."
+"L_TCR_RGN_OWB\n"
+".set .Ltcrval, .Ltcrval | .L_TCR_RGN_IWB | .L_TCR_SH_INNER | ."
+"L_TCR_T0SZ_512\n"
+"\n"
+"/* Stage 1 instruction access cacheability is unaffected. */\n"
+".set .L_SCTLR_ELx_I, 0x1 << 12\n"
+"/* SP alignment fault if SP is not aligned to a 16 byte boundary. */\n"
+".set .L_SCTLR_ELx_SA, 0x1 << 3\n"
+"/* Stage 1 data access cacheability is unaffected. */\n"
+".set .L_SCTLR_ELx_C, 0x1 << 2\n"
+"/* EL0 and EL1 stage 1 MMU enabled. */\n"
+".set .L_SCTLR_ELx_M, 0x1 << 0\n"
+"/* Privileged Access Never is unchanged on taking an exception to EL1. */\n"
+".set .L_SCTLR_EL1_SPAN, 0x1 << 23\n"
+"/* SETEND instruction disabled at EL0 in aarch32 mode. */\n"
+".set .L_SCTLR_EL1_SED, 0x1 << 8\n"
+"/* Various IT instructions are disabled at EL0 in aarch32 mode. */\n"
+".set .L_SCTLR_EL1_ITD, 0x1 << 7\n"
+".set .L_SCTLR_EL1_RES1, (0x1 << 11) | (0x1 << 20) | (0x1 << 22) | (0x1 << "
+"28) | (0x1 << 29)\n"
+".set .Lsctlrval, .L_SCTLR_ELx_M | .L_SCTLR_ELx_C | .L_SCTLR_ELx_SA | ."
+"L_SCTLR_EL1_ITD | .L_SCTLR_EL1_SED\n"
+".set .Lsctlrval, .Lsctlrval | .L_SCTLR_ELx_I | .L_SCTLR_EL1_SPAN | ."
+"L_SCTLR_EL1_RES1\n"
+"\n"
+"/**\n"
+" * This is a generic entry point for an image. It carries out the operations "
+"required to prepare the\n"
+" * loaded image to be run. Specifically, it zeroes the bss section using "
+"registers x25 and above,\n"
+" * prepares the stack, enables floating point, and sets up the exception "
+"vector. It preserves x0-x3\n"
+" * for the Rust entry point, as these may contain boot parameters.\n"
+" */\n"
+".section .init.entry, \"ax\"\n"
+".global entry\n"
+"entry:\n"
+"\t/* Load and apply the memory management configuration, ready to enable MMU "
+"and caches. */\n"
+"\tadrp x30, idmap\n"
+"\tmsr ttbr0_el1, x30\n"
+"\n"
+"\tmov_i x30, .Lmairval\n"
+"\tmsr mair_el1, x30\n"
+"\n"
+"\tmov_i x30, .Ltcrval\n"
+"\t/* Copy the supported PA range into TCR_EL1.IPS. */\n"
+"\tmrs x29, id_aa64mmfr0_el1\n"
+"\tbfi x30, x29, #32, #4\n"
+"\n"
+"\tmsr tcr_el1, x30\n"
+"\n"
+"\tmov_i x30, .Lsctlrval\n"
+"\n"
+"\t/*\n"
+"\t * Ensure everything before this point has completed, then invalidate any "
+"potentially stale\n"
+"\t * local TLB entries before they start being used.\n"
+"\t */\n"
+"\tisb\n"
+"\ttlbi vmalle1\n"
+"\tic iallu\n"
+"\tdsb nsh\n"
+"\tisb\n"
+"\n"
+"\t/*\n"
+"\t * Configure sctlr_el1 to enable MMU and cache and don't proceed until "
+"this has completed.\n"
+"\t */\n"
+"\tmsr sctlr_el1, x30\n"
+"\tisb\n"
+"\n"
+"\t/* Disable trapping floating point access in EL1. */\n"
+"\tmrs x30, cpacr_el1\n"
+"\torr x30, x30, #(0x3 << 20)\n"
+"\tmsr cpacr_el1, x30\n"
+"\tisb\n"
+"\n"
+"\t/* Zero out the bss section. */\n"
+"\tadr_l x29, bss_begin\n"
+"\tadr_l x30, bss_end\n"
+"0:\tcmp x29, x30\n"
+"\tb.hs 1f\n"
+"\tstp xzr, xzr, [x29], #16\n"
+"\tb 0b\n"
+"\n"
+"1:\t/* Prepare the stack. */\n"
+"\tadr_l x30, boot_stack_end\n"
+"\tmov sp, x30\n"
+"\n"
+"\t/* Set up exception vector. */\n"
+"\tadr x30, vector_table_el1\n"
+"\tmsr vbar_el1, x30\n"
+"\n"
+"\t/* Call into Rust code. */\n"
+"\tbl main\n"
+"\n"
+"\t/* Loop forever waiting for interrupts. */\n"
+"2:\twfi\n"
+"\tb 2b\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:595
+msgid "`exceptions.S` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:599
+msgid ""
+"```armasm\n"
+"/*\n"
+" * Copyright 2023 Google LLC\n"
+" *\n"
+" * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+" * you may not use this file except in compliance with the License.\n"
+" * You may obtain a copy of the License at\n"
+" *\n"
+" *     https://www.apache.org/licenses/LICENSE-2.0\n"
+" *\n"
+" * Unless required by applicable law or agreed to in writing, software\n"
+" * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+" * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+" * See the License for the specific language governing permissions and\n"
+" * limitations under the License.\n"
+" */\n"
+"\n"
+"/**\n"
+" * Saves the volatile registers onto the stack. This currently takes 14\n"
+" * instructions, so it can be used in exception handlers with 18 "
+"instructions\n"
+" * left.\n"
+" *\n"
+" * On return, x0 and x1 are initialised to elr_el2 and spsr_el2 "
+"respectively,\n"
+" * which can be used as the first and second arguments of a subsequent "
+"call.\n"
+" */\n"
+".macro save_volatile_to_stack\n"
+"\t/* Reserve stack space and save registers x0-x18, x29 & x30. */\n"
+"\tstp x0, x1, [sp, #-(8 * 24)]!\n"
+"\tstp x2, x3, [sp, #8 * 2]\n"
+"\tstp x4, x5, [sp, #8 * 4]\n"
+"\tstp x6, x7, [sp, #8 * 6]\n"
+"\tstp x8, x9, [sp, #8 * 8]\n"
+"\tstp x10, x11, [sp, #8 * 10]\n"
+"\tstp x12, x13, [sp, #8 * 12]\n"
+"\tstp x14, x15, [sp, #8 * 14]\n"
+"\tstp x16, x17, [sp, #8 * 16]\n"
+"\tstr x18, [sp, #8 * 18]\n"
+"\tstp x29, x30, [sp, #8 * 20]\n"
+"\n"
+"\t/*\n"
+"\t * Save elr_el1 & spsr_el1. This such that we can take nested exception\n"
+"\t * and still be able to unwind.\n"
+"\t */\n"
+"\tmrs x0, elr_el1\n"
+"\tmrs x1, spsr_el1\n"
+"\tstp x0, x1, [sp, #8 * 22]\n"
+".endm\n"
+"\n"
+"/**\n"
+" * Restores the volatile registers from the stack. This currently takes 14\n"
+" * instructions, so it can be used in exception handlers while still leaving "
+"18\n"
+" * instructions left; if paired with save_volatile_to_stack, there are 4\n"
+" * instructions to spare.\n"
+" */\n"
+".macro restore_volatile_from_stack\n"
+"\t/* Restore registers x2-x18, x29 & x30. */\n"
+"\tldp x2, x3, [sp, #8 * 2]\n"
+"\tldp x4, x5, [sp, #8 * 4]\n"
+"\tldp x6, x7, [sp, #8 * 6]\n"
+"\tldp x8, x9, [sp, #8 * 8]\n"
+"\tldp x10, x11, [sp, #8 * 10]\n"
+"\tldp x12, x13, [sp, #8 * 12]\n"
+"\tldp x14, x15, [sp, #8 * 14]\n"
+"\tldp x16, x17, [sp, #8 * 16]\n"
+"\tldr x18, [sp, #8 * 18]\n"
+"\tldp x29, x30, [sp, #8 * 20]\n"
+"\n"
+"\t/* Restore registers elr_el1 & spsr_el1, using x0 & x1 as scratch. */\n"
+"\tldp x0, x1, [sp, #8 * 22]\n"
+"\tmsr elr_el1, x0\n"
+"\tmsr spsr_el1, x1\n"
+"\n"
+"\t/* Restore x0 & x1, and release stack space. */\n"
+"\tldp x0, x1, [sp], #8 * 24\n"
+".endm\n"
+"\n"
+"/**\n"
+" * This is a generic handler for exceptions taken at the current EL while "
+"using\n"
+" * SP0. It behaves similarly to the SPx case by first switching to SPx, "
+"doing\n"
+" * the work, then switching back to SP0 before returning.\n"
+" *\n"
+" * Switching to SPx and calling the Rust handler takes 16 instructions. To\n"
+" * restore and return we need an additional 16 instructions, so we can "
+"implement\n"
+" * the whole handler within the allotted 32 instructions.\n"
+" */\n"
+".macro current_exception_sp0 handler:req\n"
+"\tmsr spsel, #1\n"
+"\tsave_volatile_to_stack\n"
+"\tbl \\handler\n"
+"\trestore_volatile_from_stack\n"
+"\tmsr spsel, #0\n"
+"\teret\n"
+".endm\n"
+"\n"
+"/**\n"
+" * This is a generic handler for exceptions taken at the current EL while "
+"using\n"
+" * SPx. It saves volatile registers, calls the Rust handler, restores "
+"volatile\n"
+" * registers, then returns.\n"
+" *\n"
+" * This also works for exceptions taken from EL0, if we don't care about\n"
+" * non-volatile registers.\n"
+" *\n"
+" * Saving state and jumping to the Rust handler takes 15 instructions, and\n"
+" * restoring and returning also takes 15 instructions, so we can fit the "
+"whole\n"
+" * handler in 30 instructions, under the limit of 32.\n"
+" */\n"
+".macro current_exception_spx handler:req\n"
+"\tsave_volatile_to_stack\n"
+"\tbl \\handler\n"
+"\trestore_volatile_from_stack\n"
+"\teret\n"
+".endm\n"
+"\n"
+".section .text.vector_table_el1, \"ax\"\n"
+".global vector_table_el1\n"
+".balign 0x800\n"
+"vector_table_el1:\n"
+"sync_cur_sp0:\n"
+"\tcurrent_exception_sp0 sync_exception_current\n"
+"\n"
+".balign 0x80\n"
+"irq_cur_sp0:\n"
+"\tcurrent_exception_sp0 irq_current\n"
+"\n"
+".balign 0x80\n"
+"fiq_cur_sp0:\n"
+"\tcurrent_exception_sp0 fiq_current\n"
+"\n"
+".balign 0x80\n"
+"serr_cur_sp0:\n"
+"\tcurrent_exception_sp0 serr_current\n"
+"\n"
+".balign 0x80\n"
+"sync_cur_spx:\n"
+"\tcurrent_exception_spx sync_exception_current\n"
+"\n"
+".balign 0x80\n"
+"irq_cur_spx:\n"
+"\tcurrent_exception_spx irq_current\n"
+"\n"
+".balign 0x80\n"
+"fiq_cur_spx:\n"
+"\tcurrent_exception_spx fiq_current\n"
+"\n"
+".balign 0x80\n"
+"serr_cur_spx:\n"
+"\tcurrent_exception_spx serr_current\n"
+"\n"
+".balign 0x80\n"
+"sync_lower_64:\n"
+"\tcurrent_exception_spx sync_lower\n"
+"\n"
+".balign 0x80\n"
+"irq_lower_64:\n"
+"\tcurrent_exception_spx irq_lower\n"
+"\n"
+".balign 0x80\n"
+"fiq_lower_64:\n"
+"\tcurrent_exception_spx fiq_lower\n"
+"\n"
+".balign 0x80\n"
+"serr_lower_64:\n"
+"\tcurrent_exception_spx serr_lower\n"
+"\n"
+".balign 0x80\n"
+"sync_lower_32:\n"
+"\tcurrent_exception_spx sync_lower\n"
+"\n"
+".balign 0x80\n"
+"irq_lower_32:\n"
+"\tcurrent_exception_spx irq_lower\n"
+"\n"
+".balign 0x80\n"
+"fiq_lower_32:\n"
+"\tcurrent_exception_spx fiq_lower\n"
+"\n"
+".balign 0x80\n"
+"serr_lower_32:\n"
+"\tcurrent_exception_spx serr_lower\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:780
+msgid "`idmap.S` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:784
+msgid ""
+"```armasm\n"
+"/*\n"
+" * Copyright 2023 Google LLC\n"
+" *\n"
+" * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+" * you may not use this file except in compliance with the License.\n"
+" * You may obtain a copy of the License at\n"
+" *\n"
+" *     https://www.apache.org/licenses/LICENSE-2.0\n"
+" *\n"
+" * Unless required by applicable law or agreed to in writing, software\n"
+" * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+" * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+" * See the License for the specific language governing permissions and\n"
+" * limitations under the License.\n"
+" */\n"
+"\n"
+".set .L_TT_TYPE_BLOCK, 0x1\n"
+".set .L_TT_TYPE_PAGE,  0x3\n"
+".set .L_TT_TYPE_TABLE, 0x3\n"
+"\n"
+"/* Access flag. */\n"
+".set .L_TT_AF, 0x1 << 10\n"
+"/* Not global. */\n"
+".set .L_TT_NG, 0x1 << 11\n"
+".set .L_TT_XN, 0x3 << 53\n"
+"\n"
+".set .L_TT_MT_DEV, 0x0 << 2\t\t\t// MAIR #0 (DEV_nGnRE)\n"
+".set .L_TT_MT_MEM, (0x1 << 2) | (0x3 << 8)\t// MAIR #1 (MEM_WBWA), inner "
+"shareable\n"
+"\n"
+".set .L_BLOCK_DEV, .L_TT_TYPE_BLOCK | .L_TT_MT_DEV | .L_TT_AF | .L_TT_XN\n"
+".set .L_BLOCK_MEM, .L_TT_TYPE_BLOCK | .L_TT_MT_MEM | .L_TT_AF | .L_TT_NG\n"
+"\n"
+".section \".rodata.idmap\", \"a\", %progbits\n"
+".global idmap\n"
+".align 12\n"
+"idmap:\n"
+"\t/* level 1 */\n"
+"\t.quad\t\t.L_BLOCK_DEV | 0x0\t\t    // 1 GiB of device mappings\n"
+"\t.quad\t\t.L_BLOCK_MEM | 0x40000000\t// 1 GiB of DRAM\n"
+"\t.fill\t\t254, 8, 0x0\t\t\t// 254 GiB of unmapped VA space\n"
+"\t.quad\t\t.L_BLOCK_DEV | 0x4000000000 // 1 GiB of device mappings\n"
+"\t.fill\t\t255, 8, 0x0\t\t\t// 255 GiB of remaining VA space\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:829
+msgid "`image.ld` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:833
+msgid ""
+"```ld\n"
+"/*\n"
+" * Copyright 2023 Google LLC\n"
+" *\n"
+" * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+" * you may not use this file except in compliance with the License.\n"
+" * You may obtain a copy of the License at\n"
+" *\n"
+" *     https://www.apache.org/licenses/LICENSE-2.0\n"
+" *\n"
+" * Unless required by applicable law or agreed to in writing, software\n"
+" * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+" * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+" * See the License for the specific language governing permissions and\n"
+" * limitations under the License.\n"
+" */\n"
+"\n"
+"/*\n"
+" * Code will start running at this symbol which is placed at the start of "
+"the\n"
+" * image.\n"
+" */\n"
+"ENTRY(entry)\n"
+"\n"
+"MEMORY\n"
+"{\n"
+"\timage : ORIGIN = 0x40080000, LENGTH = 2M\n"
+"}\n"
+"\n"
+"SECTIONS\n"
+"{\n"
+"\t/*\n"
+"\t * Collect together the code.\n"
+"\t */\n"
+"\t.init : ALIGN(4096) {\n"
+"\t\ttext_begin = .;\n"
+"\t\t*(.init.entry)\n"
+"\t\t*(.init.*)\n"
+"\t} >image\n"
+"\t.text : {\n"
+"\t\t*(.text.*)\n"
+"\t} >image\n"
+"\ttext_end = .;\n"
+"\n"
+"\t/*\n"
+"\t * Collect together read-only data.\n"
+"\t */\n"
+"\t.rodata : ALIGN(4096) {\n"
+"\t\trodata_begin = .;\n"
+"\t\t*(.rodata.*)\n"
+"\t} >image\n"
+"\t.got : {\n"
+"\t\t*(.got)\n"
+"\t} >image\n"
+"\trodata_end = .;\n"
+"\n"
+"\t/*\n"
+"\t * Collect together the read-write data including .bss at the end which\n"
+"\t * will be zero'd by the entry code.\n"
+"\t */\n"
+"\t.data : ALIGN(4096) {\n"
+"\t\tdata_begin = .;\n"
+"\t\t*(.data.*)\n"
+"\t\t/*\n"
+"\t\t * The entry point code assumes that .data is a multiple of 32\n"
+"\t\t * bytes long.\n"
+"\t\t */\n"
+"\t\t. = ALIGN(32);\n"
+"\t\tdata_end = .;\n"
+"\t} >image\n"
+"\n"
+"\t/* Everything beyond this point will not be included in the binary. */\n"
+"\tbin_end = .;\n"
+"\n"
+"\t/* The entry point code assumes that .bss is 16-byte aligned. */\n"
+"\t.bss : ALIGN(16)  {\n"
+"\t\tbss_begin = .;\n"
+"\t\t*(.bss.*)\n"
+"\t\t*(COMMON)\n"
+"\t\t. = ALIGN(16);\n"
+"\t\tbss_end = .;\n"
+"\t} >image\n"
+"\n"
+"\t.stack (NOLOAD) : ALIGN(4096) {\n"
+"\t\tboot_stack_begin = .;\n"
+"\t\t. += 40 * 4096;\n"
+"\t\t. = ALIGN(4096);\n"
+"\t\tboot_stack_end = .;\n"
+"\t} >image\n"
+"\n"
+"\t. = ALIGN(4K);\n"
+"\tPROVIDE(dma_region = .);\n"
+"\n"
+"\t/*\n"
+"\t * Remove unused sections from the image.\n"
+"\t */\n"
+"\t/DISCARD/ : {\n"
+"\t\t/* The image loads itself so doesn't need these sections. */\n"
+"\t\t*(.gnu.hash)\n"
+"\t\t*(.hash)\n"
+"\t\t*(.interp)\n"
+"\t\t*(.eh_frame_hdr)\n"
+"\t\t*(.eh_frame)\n"
+"\t\t*(.note.gnu.build-id)\n"
+"\t}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:940
+msgid "`Makefile` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:944
+msgid ""
+"```makefile\n"
+"# Copyright 2023 Google LLC\n"
+"#\n"
+"# Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"# you may not use this file except in compliance with the License.\n"
+"# You may obtain a copy of the License at\n"
+"#\n"
+"#      http://www.apache.org/licenses/LICENSE-2.0\n"
+"#\n"
+"# Unless required by applicable law or agreed to in writing, software\n"
+"# distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"# See the License for the specific language governing permissions and\n"
+"# limitations under the License.\n"
+"\n"
+"UNAME := $(shell uname -s)\n"
+"ifeq ($(UNAME),Linux)\n"
+"\tTARGET = aarch64-linux-gnu\n"
+"else\n"
+"\tTARGET = aarch64-none-elf\n"
+"endif\n"
+"OBJCOPY = $(TARGET)-objcopy\n"
+"\n"
+".PHONY: build qemu_minimal qemu qemu_logger\n"
+"\n"
+"all: rtc.bin\n"
+"\n"
+"build:\n"
+"\tcargo build\n"
+"\n"
+"rtc.bin: build\n"
+"\t$(OBJCOPY) -O binary target/aarch64-unknown-none/debug/rtc $@\n"
+"\n"
+"qemu: rtc.bin\n"
+"\tqemu-system-aarch64 -machine virt,gic-version=3 -cpu max -serial mon:stdio "
+"-display none -kernel $< -s\n"
+"\n"
+"clean:\n"
+"\tcargo clean\n"
+"\trm -f *.bin\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:989
+msgid ""
+"```toml\n"
+"[build]\n"
+"target = \"aarch64-unknown-none\"\n"
+"rustflags = [\"-C\", \"link-arg=-Timage.ld\"]\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/rtc.md:995
+msgid "Run the code in QEMU with `make qemu`."
+msgstr ""
+
+#: src/concurrency.md:1
+#, fuzzy
+msgid "Welcome to Concurrency in Rust"
+msgstr "Welcome to Comprehensive Rust 🦀"
+
+#: src/concurrency.md:3
+msgid ""
+"Rust has full support for concurrency using OS threads with mutexes and "
+"channels."
+msgstr ""
+"러스트는 동시성 지원이 막강합니다. 운영체제 레벨의 스레드를 사용하며, 뮤택스"
+"와 채널도 지원합니다."
+
+#: src/concurrency.md:6
+msgid ""
+"The Rust type system plays an important role in making many concurrency bugs "
+"compile time bugs. This is often referred to as _fearless concurrency_ since "
+"you can rely on the compiler to ensure correctness at runtime."
+msgstr ""
+"러스트의 타입 시스템은 프로그램에 동시성 버그가 있을 경우, 컴파일 시에 에러"
+"가 발생하도록 해 줍니다. 컴파일러를 이용해서 프로그램이 수행시에 정확히 동작"
+"함을 미리 보장해 주기 때문에, 사람들은 이를 종종 _겁없는 동시성_ 이라고 합니"
+"다."
+
+#: src/concurrency/threads.md:3
+msgid "Rust threads work similarly to threads in other languages:"
+msgstr "러스트의 스레드는 다른 언어의 스레드와 유사하게 동작합니다:"
+
+#: src/concurrency/threads.md:5
+msgid ""
+"```rust,editable\n"
+"use std::thread;\n"
+"use std::time::Duration;\n"
+"\n"
+"fn main() {\n"
+"    thread::spawn(|| {\n"
+"        for i in 1..10 {\n"
+"            println!(\"Count in thread: {i}!\");\n"
+"            thread::sleep(Duration::from_millis(5));\n"
+"        }\n"
+"    });\n"
+"\n"
+"    for i in 1..5 {\n"
+"        println!(\"Main thread: {i}\");\n"
+"        thread::sleep(Duration::from_millis(5));\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::thread;\n"
+"use std::time::Duration;\n"
+"\n"
+"fn main() {\n"
+"    thread::spawn(|| {\n"
+"        for i in 1..10 {\n"
+"            println!(\"Count in thread: {i}!\");\n"
+"            thread::sleep(Duration::from_millis(5));\n"
+"        }\n"
+"    });\n"
+"\n"
+"    for i in 1..5 {\n"
+"        println!(\"Main thread: {i}\");\n"
+"        thread::sleep(Duration::from_millis(5));\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/concurrency/threads.md:24
+msgid "Threads are all daemon threads, the main thread does not wait for them."
+msgstr ""
+"스레드는 모두 데몬 스레드입니다. 따라서 메인 스레드는 이 스레드들이 끝나기를 "
+"기다리지 않습니다."
+
+#: src/concurrency/threads.md:25
+msgid "Thread panics are independent of each other."
+msgstr "한 스레드에서 발생한 패닉은 다른 스레드에게 영향을 끼치지 않습니다."
+
+#: src/concurrency/threads.md:26
+msgid "Panics can carry a payload, which can be unpacked with `downcast_ref`."
+msgstr ""
+"패닉은 추가정보(페이로드)를 포함할 수 있으며, 이는 `downcast_ref`로 풀어볼 "
+"수 있습니다."
+
+#: src/concurrency/threads.md:32
+msgid ""
+"Notice that the thread is stopped before it reaches 10 — the main thread is "
+"not waiting."
+msgstr ""
+"메인 스레드가 자식 스레드를 기다리지 않기 때문에 자식 스레드의 for문은 10까"
+"지 가지 않습니다."
+
+#: src/concurrency/threads.md:35
+msgid ""
+"Use `let handle = thread::spawn(...)` and later `handle.join()` to wait for "
+"the thread to finish."
+msgstr ""
+"만약 메인 스레드가 자식 스레드가 끝날 때 까지 기다리기를 원한다면 `let "
+"handle = thread::spawn(...)`으로 스레드를 선언한 후 `handle.join()`로 연결하"
+"여 사용합니다."
+
+#: src/concurrency/threads.md:38
+msgid "Trigger a panic in the thread, notice how this doesn't affect `main`."
+msgstr ""
+"자식 스레드에서 발생한 패닉이 메인 스레드에는 영향을 주지 않음을 확인하시기 "
+"바랍니다."
+
+#: src/concurrency/threads.md:40
+msgid ""
+"Use the `Result` return value from `handle.join()` to get access to the "
+"panic payload. This is a good time to talk about [`Any`](https://doc.rust-"
+"lang.org/std/any/index.html)."
+msgstr ""
+"`handle.join()`사용시 `Result` 반환값을 통해 패닉의 추가정보에 접근할 수 있습"
+"니다. 이 시점에서 [`Any`](https://doc.rust-lang.org/std/any/index.html)에 대"
+"해 이야기를 해 보면 좋습니다."
+
+#: src/concurrency/scoped-threads.md:3
+msgid "Normal threads cannot borrow from their environment:"
+msgstr "보통, 스레드는 스레드 밖에서 데이터를 빌릴 수 없습니다:"
+
+#: src/concurrency/scoped-threads.md:5
+#, fuzzy
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::thread;\n"
+"\n"
+"fn foo() {\n"
+"    let s = String::from(\"Hello\");\n"
+"    thread::spawn(|| {\n"
+"        println!(\"Length: {}\", s.len());\n"
+"    });\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    foo();\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use std::thread;\n"
+"\n"
+"fn main() {\n"
+"    let s = String::from(\"Hello\");\n"
+"\n"
+"    thread::spawn(|| {\n"
+"        println!(\"Length: {}\", s.len());\n"
+"    });\n"
+"}\n"
+"```"
+
+#: src/concurrency/scoped-threads.md:20
+msgid ""
+"However, you can use a [scoped thread](https://doc.rust-lang.org/std/thread/"
+"fn.scope.html) for this:"
+msgstr ""
+"하지만, [scoped thread](https://doc.rust-lang.org/std/thread/fn.scope.html)에"
+"서는 가능합니다:"
+
+#: src/concurrency/scoped-threads.md:22
+msgid ""
+"```rust,editable\n"
+"use std::thread;\n"
+"\n"
+"fn main() {\n"
+"    let s = String::from(\"Hello\");\n"
+"\n"
+"    thread::scope(|scope| {\n"
+"        scope.spawn(|| {\n"
+"            println!(\"Length: {}\", s.len());\n"
+"        });\n"
+"    });\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::thread;\n"
+"\n"
+"fn main() {\n"
+"    let s = String::from(\"Hello\");\n"
+"\n"
+"    thread::scope(|scope| {\n"
+"        scope.spawn(|| {\n"
+"            println!(\"Length: {}\", s.len());\n"
+"        });\n"
+"    });\n"
+"}\n"
+"```"
+
+#: src/concurrency/scoped-threads.md:40
+msgid ""
+"The reason for that is that when the `thread::scope` function completes, all "
+"the threads are guaranteed to be joined, so they can return borrowed data."
+msgstr ""
+"`thread::scope` 함수가 완료되면 그 안에서 생성된 모든 스레드들이 종료했음이 "
+"보장되기 때문에, 그 때 빌렸던 데이터들을 다시 반환할 수 있기 때문입니다."
+
+#: src/concurrency/scoped-threads.md:41
+msgid ""
+"Normal Rust borrowing rules apply: you can either borrow mutably by one "
+"thread, or immutably by any number of threads."
+msgstr ""
+"일반적인 러스트의 빌림 규칙이 적용됩니다: 한 스레드에 의한 가변 빌림 또는 여"
+"러 스레드에 대한 불변 빌림중 하나만 가능합니다."
+
+#: src/concurrency/channels.md:3
+msgid ""
+"Rust channels have two parts: a `Sender<T>` and a `Receiver<T>`. The two "
+"parts are connected via the channel, but you only see the end-points."
+msgstr ""
+"러스트의 채널은 `Sender<T>` 와 `Receiver<T>` 두 부분으로 구성됩니다. 이 둘은 "
+"채널을 통해 서로 연결되어 있지만, 우리는 채널을 볼 수는 없고 이 양 끝단만을 "
+"사용하게 됩니다."
+
+#: src/concurrency/channels.md:6
+msgid ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;\n"
+"\n"
+"fn main() {\n"
+"    let (tx, rx) = mpsc::channel();\n"
+"\n"
+"    tx.send(10).unwrap();\n"
+"    tx.send(20).unwrap();\n"
+"\n"
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"\n"
+"    let tx2 = tx.clone();\n"
+"    tx2.send(30).unwrap();\n"
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;\n"
+"\n"
+"fn main() {\n"
+"    let (tx, rx) = mpsc::channel();\n"
+"\n"
+"    tx.send(10).unwrap();\n"
+"    tx.send(20).unwrap();\n"
+"\n"
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"\n"
+"    let tx2 = tx.clone();\n"
+"    tx2.send(30).unwrap();\n"
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"}\n"
+"```"
+
+#: src/concurrency/channels.md:27
+msgid ""
+"`mpsc` stands for Multi-Producer, Single-Consumer. `Sender` and `SyncSender` "
+"implement `Clone` (so you can make multiple producers) but `Receiver` does "
+"not."
+msgstr ""
+"`mpsc`는 “Multi-Produce, Single-Consumer”를 의미합니다. `Sender`와 "
+"`SyncSender`는 `Clone`을 구현하지만 (즉, 여러개의 producer를 만들수 있습니"
+"다) `Receiver`는 `Clone`을 구현하지 않습니다."
+
+#: src/concurrency/channels.md:29
+msgid ""
+"`send()` and `recv()` return `Result`. If they return `Err`, it means the "
+"counterpart `Sender` or `Receiver` is dropped and the channel is closed."
+msgstr ""
+"`send()`와 `recv()`는 `Result`를 반환합니다. 만일 `Err`가 반환된다면, 상대방"
+"의 `Sender`또는 `Receiver`가 삭제되었고 채널이 닫혔다는 뜻입니다."
+
+#: src/concurrency/channels/unbounded.md:3
+msgid "You get an unbounded and asynchronous channel with `mpsc::channel()`:"
+msgstr "`mpsc::channel()` 함수는 경계가 없는 비동기 채널을 생성합니다:"
+
+#: src/concurrency/channels/unbounded.md:5
+msgid ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;\n"
+"use std::time::Duration;\n"
+"\n"
+"fn main() {\n"
+"    let (tx, rx) = mpsc::channel();\n"
+"\n"
+"    thread::spawn(move || {\n"
+"        let thread_id = thread::current().id();\n"
+"        for i in 1..10 {\n"
+"            tx.send(format!(\"Message {i}\")).unwrap();\n"
+"            println!(\"{thread_id:?}: sent Message {i}\");\n"
+"        }\n"
+"        println!(\"{thread_id:?}: done\");\n"
+"    });\n"
+"    thread::sleep(Duration::from_millis(100));\n"
+"\n"
+"    for msg in rx.iter() {\n"
+"        println!(\"Main: got {msg}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;\n"
+"use std::time::Duration;\n"
+"\n"
+"fn main() {\n"
+"    let (tx, rx) = mpsc::channel();\n"
+"\n"
+"    thread::spawn(move || {\n"
+"        let thread_id = thread::current().id();\n"
+"        for i in 1..10 {\n"
+"            tx.send(format!(\"Message {i}\")).unwrap();\n"
+"            println!(\"{thread_id:?}: sent Message {i}\");\n"
+"        }\n"
+"        println!(\"{thread_id:?}: done\");\n"
+"    });\n"
+"    thread::sleep(Duration::from_millis(100));\n"
+"\n"
+"    for msg in rx.iter() {\n"
+"        println!(\"Main: got {msg}\");\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/concurrency/channels/bounded.md:3
+#, fuzzy
+msgid ""
+"With bounded (synchronous) channels, `send` can block the current thread:"
+msgstr "경계가 있는 동기 채널은 `send`가 현제 스레드를 블로킹 하도록 만듭니다:"
+
+#: src/concurrency/channels/bounded.md:5
+msgid ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;\n"
+"use std::time::Duration;\n"
+"\n"
+"fn main() {\n"
+"    let (tx, rx) = mpsc::sync_channel(3);\n"
+"\n"
+"    thread::spawn(move || {\n"
+"        let thread_id = thread::current().id();\n"
+"        for i in 1..10 {\n"
+"            tx.send(format!(\"Message {i}\")).unwrap();\n"
+"            println!(\"{thread_id:?}: sent Message {i}\");\n"
+"        }\n"
+"        println!(\"{thread_id:?}: done\");\n"
+"    });\n"
+"    thread::sleep(Duration::from_millis(100));\n"
+"\n"
+"    for msg in rx.iter() {\n"
+"        println!(\"Main: got {msg}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;\n"
+"use std::time::Duration;\n"
+"\n"
+"fn main() {\n"
+"    let (tx, rx) = mpsc::sync_channel(3);\n"
+"\n"
+"    thread::spawn(move || {\n"
+"        let thread_id = thread::current().id();\n"
+"        for i in 1..10 {\n"
+"            tx.send(format!(\"Message {i}\")).unwrap();\n"
+"            println!(\"{thread_id:?}: sent Message {i}\");\n"
+"        }\n"
+"        println!(\"{thread_id:?}: done\");\n"
+"    });\n"
+"    thread::sleep(Duration::from_millis(100));\n"
+"\n"
+"    for msg in rx.iter() {\n"
+"        println!(\"Main: got {msg}\");\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/concurrency/channels/bounded.md:31
+msgid ""
+"Calling `send` will block the current thread until there is space in the "
+"channel for the new message. The thread can be blocked indefinitely if there "
+"is nobody who reads from the channel."
+msgstr ""
+
+#: src/concurrency/channels/bounded.md:32
+msgid ""
+"A call to `send` will abort with an error (that is why it returns `Result`) "
+"if the channel is closed. A channel is closed when the receiver is dropped."
+msgstr ""
+
+#: src/concurrency/channels/bounded.md:33
+msgid ""
+"A bounded channel with a size of zero is called a \"rendezvous channel\". "
+"Every send will block the current thread until another thread calls `read`."
+msgstr ""
+
+#: src/concurrency/send-sync.md:1
+msgid "`Send` and `Sync`"
+msgstr "`Send`와 `Sync`"
+
+#: src/concurrency/send-sync.md:3
+msgid ""
+"How does Rust know to forbid shared access across thread? The answer is in "
+"two traits:"
+msgstr ""
+"러스트는 어떻게 해서 스레드 간에 특정 데이터 타입이 공유될 수 있거나, 안된다"
+"는 것을 알까요? 정답은 다음 두 트레잇에 있습니다:"
+
+#: src/concurrency/send-sync.md:5
+msgid ""
+"[`Send`](https://doc.rust-lang.org/std/marker/trait.Send.html): a type `T` "
+"is `Send` if it is safe to move a `T` across a thread boundary."
+msgstr ""
+"[`Send`](https://doc.rust-lang.org/std/marker/trait.Send.html): `T`가 스레드 "
+"간 이동이 안전하다면, `T`의 타입은 `Send`입니다."
+
+#: src/concurrency/send-sync.md:7
+msgid ""
+"[`Sync`](https://doc.rust-lang.org/std/marker/trait.Sync.html): a type `T` "
+"is `Sync` if it is safe to move a `&T` across a thread boundary."
+msgstr ""
+"[`Sync`](https://doc.rust-lang.org/std/marker/trait.Sync.html): `&T`가 스레"
+"드 간 이동이 안전하다면, `&T`의 타입은 `Sync`입니다."
+
+#: src/concurrency/send-sync.md:10
+msgid ""
+"`Send` and `Sync` are [unsafe traits](../unsafe/unsafe-traits.md). The "
+"compiler will automatically derive them for your types as long as they only "
+"contain `Send` and `Sync` types. You can also implement them manually when "
+"you know it is valid."
+msgstr ""
+"`Send`와 `Sync` 트레잇은 [안전하지 않은 트레잇](../unsafe/unsafe-traits.md)입"
+"니다. 컴파일러는 타입의 요소들이 모두 `Send`와 `Sync` 타입이면 자동으로 이 트"
+"레잇들을 적용시켜 줍니다. 물론 여러분 스스로 맞다고 알고 있다면 직접 구현해"
+"도 됩니다."
+
+#: src/concurrency/send-sync.md:20
+msgid ""
+"One can think of these traits as markers that the type has certain thread-"
+"safety properties."
+msgstr ""
+"`Sync`와 `Send`는 어떤 타입이 특정한 스레드-안전 속성을 가짐을 나타내는 마커"
+"로 생각할 수 있습니다."
+
+#: src/concurrency/send-sync.md:21
+msgid "They can be used in the generic constraints as normal traits."
+msgstr ""
+"이 두 트레이트는 제너릭에서 제약 조건을 나타내는 트레이트로 사용될 수도 있습"
+"니다."
+
+#: src/concurrency/send-sync/send.md:1
+msgid "`Send`"
+msgstr "`Send`"
+
+#: src/concurrency/send-sync/send.md:3
+msgid ""
+"A type `T` is [`Send`](https://doc.rust-lang.org/std/marker/trait.Send.html) "
+"if it is safe to move a `T` value to another thread."
+msgstr ""
+"`T`가 스레드 간에 안전하게 이동될 수 있다면, `T`의 타입은 `Send`입니다."
+
+#: src/concurrency/send-sync/send.md:5
+msgid ""
+"The effect of moving ownership to another thread is that _destructors_ will "
+"run in that thread. So the question is when you can allocate a value in one "
+"thread and deallocate it in another."
+msgstr ""
+"소유권을 다른 스레드로 이동하면 소멸자가 해당 스레드에서 실행됩니다. 여기서 "
+"의문은 \"언제 한 스레드에서 값을 할당하고 다른 스레드에서 값을 할당 해제할 "
+"수 있는가\" 입니다."
+
+#: src/concurrency/send-sync/send.md:13
+msgid ""
+"As an example, a connection to the SQLite library must only be accessed from "
+"a single thread."
+msgstr ""
+"예를 들어 SQLite 라이브러리 연결은 단일 스레드에서만 액세스해야 합니다."
+
+#: src/concurrency/send-sync/sync.md:1
+msgid "`Sync`"
+msgstr "`Sync`"
+
+#: src/concurrency/send-sync/sync.md:3
+msgid ""
+"A type `T` is [`Sync`](https://doc.rust-lang.org/std/marker/trait.Sync.html) "
+"if it is safe to access a `T` value from multiple threads at the same time."
+msgstr ""
+"`&T`가 여러 스레드에서 안전하게 접근될 수 있다면, `&T`의 타입은 `Sync`입니다."
+
+#: src/concurrency/send-sync/sync.md:6
+msgid "More precisely, the definition is:"
+msgstr "좀 더 정확한 정의는 다음과 같습니다:"
+
+#: src/concurrency/send-sync/sync.md:8
+msgid "`T` is `Sync` if and only if `&T` is `Send`"
+msgstr "`&T`가 `Send`인 경우에만 `T`의 타입이 `Sync`가 됩니다"
+
+#: src/concurrency/send-sync/sync.md:14
+msgid ""
+"This statement is essentially a shorthand way of saying that if a type is "
+"thread-safe for shared use, it is also thread-safe to pass references of it "
+"across threads."
+msgstr ""
+"위 문장을 풀어서 이야기 하면, 어떤 타입이 스레드 간에 공유되어서 사용되기에 "
+"안전하다면 그 타입의 참조 타입은 스레드 간에 이동 가능하다는 것입니다."
+
+#: src/concurrency/send-sync/sync.md:16
+msgid ""
+"This is because if a type is Sync it means that it can be shared across "
+"multiple threads without the risk of data races or other synchronization "
+"issues, so it is safe to move it to another thread. A reference to the type "
+"is also safe to move to another thread, because the data it references can "
+"be accessed from any thread safely."
+msgstr ""
+"이는 다음과 같이 증명할 수 있습니다: 어떤 타입이 `Sync`라는 말은 곧 그 타입"
+"이 여러 스레드들 사이에서 데이터 레이스나 여타 동기화 문제 없이 공유 가능하다"
+"는 말입니다. 스레드 간 공유가 안전하다면, 스레드간 이동도 안전할 수 밖에 없습"
+"니다. 어떤 타입의 스레드간 이동이 안전하다면, 그 타입의 참조 또한 스레드간 이"
+"동이 안전할 수 밖에 없습니다."
+
+#: src/concurrency/send-sync/examples.md:3
+msgid "`Send + Sync`"
+msgstr "`Send + Sync`"
+
+#: src/concurrency/send-sync/examples.md:5
+msgid "Most types you come across are `Send + Sync`:"
+msgstr "여러분이 다루게 될 대부분의 타입은 `Send + Sync`입니다:"
+
+#: src/concurrency/send-sync/examples.md:7
+msgid "`i8`, `f32`, `bool`, `char`, `&str`, ..."
+msgstr "`i8`, `f32`, `bool`, `char`, `&str`, ..."
+
+#: src/concurrency/send-sync/examples.md:8
+msgid "`(T1, T2)`, `[T; N]`, `&[T]`, `struct { x: T }`, ..."
+msgstr "`(T1, T2)`, `[T; N]`, `&[T]`, `struct { x: T }`, ..."
+
+#: src/concurrency/send-sync/examples.md:9
+msgid "`String`, `Option<T>`, `Vec<T>`, `Box<T>`, ..."
+msgstr "`String`, `Option<T>`, `Vec<T>`, `Box<T>`, ..."
+
+#: src/concurrency/send-sync/examples.md:10
+msgid "`Arc<T>`: Explicitly thread-safe via atomic reference count."
+msgstr "`Arc<T>`: 참조 카운트 조작을 아토믹 하기 때문에 스레드 안전함."
+
+#: src/concurrency/send-sync/examples.md:11
+msgid "`Mutex<T>`: Explicitly thread-safe via internal locking."
+msgstr ""
+"`Mutex<T>`: 값을 접근하기 위해 뮤택스를 잠궈야 하기 때문에 스레드 안전함."
+
+#: src/concurrency/send-sync/examples.md:12
+msgid "`AtomicBool`, `AtomicU8`, ...: Uses special atomic instructions."
+msgstr ""
+"`AtomicBool`, `AtomicU8`, ...: 값을 접근할 때 특별한 아토믹 명령어들을 사용합"
+"니다."
+
+#: src/concurrency/send-sync/examples.md:14
+msgid ""
+"The generic types are typically `Send + Sync` when the type parameters are "
+"`Send + Sync`."
+msgstr ""
+"제네릭 타입은 일반적으로 타입 파라메터가 `Send + Sync`이면 `Send + Sync` 입니"
+"다."
+
+#: src/concurrency/send-sync/examples.md:17
+msgid "`Send + !Sync`"
+msgstr "`Send + !Sync`"
+
+#: src/concurrency/send-sync/examples.md:19
+msgid ""
+"These types can be moved to other threads, but they're not thread-safe. "
+"Typically because of interior mutability:"
+msgstr ""
+"아래 타입들은 다른 스레드로 이동될 수 있지만 내부적으로 값이 변경될 수 있기 "
+"때문에 스레드 안전하지 않습니다:"
+
+#: src/concurrency/send-sync/examples.md:22
+msgid "`mpsc::Sender<T>`"
+msgstr "`mpsc::Sender<T>`"
+
+#: src/concurrency/send-sync/examples.md:23
+msgid "`mpsc::Receiver<T>`"
+msgstr "`mpsc::Receiver<T>`"
+
+#: src/concurrency/send-sync/examples.md:24
+msgid "`Cell<T>`"
+msgstr "`Cell<T>`"
+
+#: src/concurrency/send-sync/examples.md:25
+msgid "`RefCell<T>`"
+msgstr "`RefCell<T>`"
+
+#: src/concurrency/send-sync/examples.md:27
+msgid "`!Send + Sync`"
+msgstr "`!Send + Sync`"
+
+#: src/concurrency/send-sync/examples.md:29
+msgid ""
+"These types are thread-safe, but they cannot be moved to another thread:"
+msgstr "아래 타입들은 스레드 안전하지만 다른 스레드로 이동될 수 없습니다:"
+
+#: src/concurrency/send-sync/examples.md:31
+msgid ""
+"`MutexGuard<T>`: Uses OS level primitives which must be deallocated on the "
+"thread which created them."
+msgstr ""
+"`MutexGuard<T>`: 내부적으로, 운영체제가 제공하는 primitive를 사용하는데, 이 "
+"primitive는 생성된 스레드에서 해제가 이루어져야 합니다. (_역주_: 그래서 다른 "
+"스레드로 옮길 수 없습니다.)"
+
+#: src/concurrency/send-sync/examples.md:34
+msgid "`!Send + !Sync`"
+msgstr "`!Send + !Sync`"
+
+#: src/concurrency/send-sync/examples.md:36
+msgid "These types are not thread-safe and cannot be moved to other threads:"
+msgstr ""
+"아래 타입들은 스레드 안전하지도 않고 다른 스레드로 이동될 수도 없습니다:"
+
+#: src/concurrency/send-sync/examples.md:38
+msgid ""
+"`Rc<T>`: each `Rc<T>` has a reference to an `RcBox<T>`, which contains a non-"
+"atomic reference count."
+msgstr ""
+"`Rc<T>`: `Rc<T>` 는 아토믹하지 않은 방식으로 참조 카운트를 조작하는 "
+"`RcBox<T>`를 참조합니다."
+
+#: src/concurrency/send-sync/examples.md:40
+msgid ""
+"`*const T`, `*mut T`: Rust assumes raw pointers may have special concurrency "
+"considerations."
+msgstr ""
+"`*const T`, `*mut T`: 러스트는 포인터가 스레드 안전하지 않다고 가정합니다."
+
+#: src/concurrency/shared_state.md:3
+msgid ""
+"Rust uses the type system to enforce synchronization of shared data. This is "
+"primarily done via two types:"
+msgstr ""
+"러스트는 주로 아래 두 가지 타입을 이용해서 공유 데이터 동기화를 수행합니다:"
+
+#: src/concurrency/shared_state.md:6
+msgid ""
+"[`Arc<T>`](https://doc.rust-lang.org/std/sync/struct.Arc.html), atomic "
+"reference counted `T`: handles sharing between threads and takes care to "
+"deallocate `T` when the last reference is dropped,"
+msgstr ""
+"[`Arc<T>`](https://doc.rust-lang.org/std/sync/struct.Arc.html), `T`에 대한 아"
+"토믹 참조 카운트: 이 참조는 다수의 스레드 사이에서 공유될 수 있고, 참조하던 "
+"마지막 스레드가 종료할 경우 `T`를 반환합니다."
+
+#: src/concurrency/shared_state.md:8
+msgid ""
+"[`Mutex<T>`](https://doc.rust-lang.org/std/sync/struct.Mutex.html): ensures "
+"mutually exclusive access to the `T` value."
+msgstr ""
+"[`Mutex<T>`](https://doc.rust-lang.org/std/sync/struct.Mutex.html): `T`값에 "
+"대한 상호 배제 엑세스를 보장합니다."
+
+#: src/concurrency/shared_state/arc.md:1
+msgid "`Arc`"
+msgstr "`Arc`"
+
+#: src/concurrency/shared_state/arc.md:3
+#, fuzzy
+msgid ""
+"[`Arc<T>`](https://doc.rust-lang.org/std/sync/struct.Arc.html) allows shared "
+"read-only access via `Arc::clone`:"
+msgstr ""
+"[`Arc<T>`](https://doc.rust-lang.org/std/sync/struct.Arc.html)의 `clone` 메서"
+"드를 이용하면 여러 스레드가 한 데이터를 동시에 (_역주_: 그리고 안전하게. 스레"
+"드가 하나라도 살아있는 동안에는 `T`가 반환되지 않음) 읽을 수 있습니다:"
+
+#: src/concurrency/shared_state/arc.md:5
+msgid ""
+"```rust,editable\n"
+"use std::thread;\n"
+"use std::sync::Arc;\n"
+"\n"
+"fn main() {\n"
+"    let v = Arc::new(vec![10, 20, 30]);\n"
+"    let mut handles = Vec::new();\n"
+"    for _ in 1..5 {\n"
+"        let v = Arc::clone(&v);\n"
+"        handles.push(thread::spawn(move || {\n"
+"            let thread_id = thread::current().id();\n"
+"            println!(\"{thread_id:?}: {v:?}\");\n"
+"        }));\n"
+"    }\n"
+"\n"
+"    handles.into_iter().for_each(|h| h.join().unwrap());\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::thread;\n"
+"use std::sync::Arc;\n"
+"\n"
+"fn main() {\n"
+"    let v = Arc::new(vec![10, 20, 30]);\n"
+"    let mut handles = Vec::new();\n"
+"    for _ in 1..5 {\n"
+"        let v = Arc::clone(&v);\n"
+"        handles.push(thread::spawn(move || {\n"
+"            let thread_id = thread::current().id();\n"
+"            println!(\"{thread_id:?}: {v:?}\");\n"
+"        }));\n"
+"    }\n"
+"\n"
+"    handles.into_iter().for_each(|h| h.join().unwrap());\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+
+#: src/concurrency/shared_state/arc.md:29
+#, fuzzy
+msgid ""
+"`Arc` stands for \"Atomic Reference Counted\", a thread safe version of `Rc` "
+"that uses atomic operations."
+msgstr ""
+"`Arc`는 \"Atomic Reference Counted\"를 의미하며, 스레드 안정성을 보장하는 "
+"`Rc`라고 생각하면 됩니다."
+
+#: src/concurrency/shared_state/arc.md:31
+#, fuzzy
+msgid ""
+"`Arc<T>` implements `Clone` whether or not `T` does. It implements `Send` "
+"and `Sync` if and only if `T` implements them both."
+msgstr ""
+"`T`가 `Clone`을 구현하든 안하든 `Arc<T>`는 `Clone`을 구현합니다. `Send`와 "
+"`Sync`는 `T`가 이들을 구현하는 경우에만 구현됩니다."
+
+#: src/concurrency/shared_state/arc.md:33
+#, fuzzy
+msgid ""
+"`Arc::clone()` has the cost of atomic operations that get executed, but "
+"after that the use of the `T` is free."
+msgstr ""
+"`Arc::clone()`는 아토믹 연산을 수행하기 때문에 그 때 코스트가 좀 있지만, 일"
+"단 `clone()`이 끝난 후 `T`를 사용하는 대에는 아무런 오버헤드가 없습니다."
+
+#: src/concurrency/shared_state/arc.md:35
+#, fuzzy
+msgid ""
+"Beware of reference cycles, `Arc` does not use a garbage collector to detect "
+"them."
+msgstr ""
+"순환 참조가 발생하지 않도록 주의해야 합니다. 러스트는 순환 참조를 감지하는 가"
+"비지 컬랙터가 없습니다."
+
+#: src/concurrency/shared_state/arc.md:36
+#, fuzzy
+msgid "`std::sync::Weak` can help."
+msgstr "순환 참조를 피하는데 `std::sync::Weak`가 도움이 될 것입니다."
+
+#: src/concurrency/shared_state/mutex.md:1
+msgid "`Mutex`"
+msgstr "`Mutex`"
+
+#: src/concurrency/shared_state/mutex.md:3
+msgid ""
+"[`Mutex<T>`](https://doc.rust-lang.org/std/sync/struct.Mutex.html) ensures "
+"mutual exclusion _and_ allows mutable access to `T` behind a read-only "
+"interface:"
+msgstr ""
+"[`Mutex<T>`](https://doc.rust-lang.org/std/sync/struct.Mutex.html)를 이용하"
+"면 불변 참조를 통해서도 `T`의 값을 수정할 수가 있으며, _이에 더해서_ 한 번에 "
+"한 스레드만 `T`의 값을 접근(읽거나 쓰거나)함을 보장해 줍니다:"
+
+#: src/concurrency/shared_state/mutex.md:6
+msgid ""
+"```rust,editable\n"
+"use std::sync::Mutex;\n"
+"\n"
+"fn main() {\n"
+"    let v = Mutex::new(vec![10, 20, 30]);\n"
+"    println!(\"v: {:?}\", v.lock().unwrap());\n"
+"\n"
+"    {\n"
+"        let mut guard = v.lock().unwrap();\n"
+"        guard.push(40);\n"
+"    }\n"
+"\n"
+"    println!(\"v: {:?}\", v.lock().unwrap());\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::sync::Mutex;\n"
+"\n"
+"fn main() {\n"
+"    let v = Mutex::new(vec![10, 20, 30]);\n"
+"    println!(\"v: {:?}\", v.lock().unwrap());\n"
+"\n"
+"    {\n"
+"        let mut guard = v.lock().unwrap();\n"
+"        guard.push(40);\n"
+"    }\n"
+"\n"
+"    println!(\"v: {:?}\", v.lock().unwrap());\n"
+"}\n"
+"```"
+
+#: src/concurrency/shared_state/mutex.md:22
+msgid ""
+"Notice how we have a [`impl<T: Send> Sync for Mutex<T>`](https://doc.rust-"
+"lang.org/std/sync/struct.Mutex.html#impl-Sync-for-Mutex%3CT%3E) blanket "
+"implementation."
+msgstr ""
+"모든 `Mutex<T>`는 [`impl<T: Send> Sync for Mutex<T>`](https://doc.rust-lang."
+"org/std/sync/struct.Mutex.html#impl-Sync-for-Mutex%3CT%3E)를 자동으로 구현함"
+"을 참조하세요."
+
+#: src/concurrency/shared_state/mutex.md:31
+#, fuzzy
+msgid ""
+"`Mutex` in Rust looks like a collection with just one element - the "
+"protected data."
+msgstr ""
+"러스트의 `Mutex`는 오직 하나의 데이터만 담을 수 있는 컬렉션처럼 볼 수도 있습"
+"니다. 다른 컬렉션과 다른 점은, 그 데이터가 동시성 문제로부터 자유롭다는 점입"
+"니다."
+
+#: src/concurrency/shared_state/mutex.md:32
+#, fuzzy
+msgid ""
+"It is not possible to forget to acquire the mutex before accessing the "
+"protected data."
+msgstr ""
+"`Mutex`는 뮤텍스를 획득하지 않으면 보호된 데이터에 접근하는 것이 불가능  하도"
+"록 디자인 되어 있습니다."
+
+#: src/concurrency/shared_state/mutex.md:33
+#, fuzzy
+msgid ""
+"You can get an `&mut T` from an `&Mutex<T>` by taking the lock. The "
+"`MutexGuard` ensures that the `&mut T` doesn't outlive the lock being held."
+msgstr ""
+"`&Mutex<T>`에 대해 lock을 획득하면 `&mut T`를 얻을 수 있습니다. `MutexGuard`"
+"는 `&mut T`가 획득한 lock보다 오래 살아남지 않음을 보장합니다."
+
+#: src/concurrency/shared_state/mutex.md:35
+#, fuzzy
+msgid ""
+"`Mutex<T>` implements both `Send` and `Sync` iff (if and only if) `T` "
+"implements `Send`."
+msgstr ""
+"`Mutex<T>`는 오직 `T`가 `Send`를 구현하는 경우에만 `Send`와 `Sync`를 구현합니"
+"다."
+
+#: src/concurrency/shared_state/mutex.md:36
+#, fuzzy
+msgid "A read-write lock counterpart - `RwLock`."
+msgstr "읽기-쓰기 lock은 `RwLock`을 사용합니다."
+
+#: src/concurrency/shared_state/mutex.md:37
+#, fuzzy
+msgid "Why does `lock()` return a `Result`? "
+msgstr "왜 `lock()`이 `Result`를 반환할까요?"
+
+#: src/concurrency/shared_state/mutex.md:38
+#, fuzzy
+msgid ""
+"If the thread that held the `Mutex` panicked, the `Mutex` becomes "
+"\"poisoned\" to signal that the data it protected might be in an "
+"inconsistent state. Calling `lock()` on a poisoned mutex fails with a "
+"[`PoisonError`](https://doc.rust-lang.org/std/sync/struct.PoisonError.html). "
+"You can call `into_inner()` on the error to recover the data regardless."
+msgstr ""
+"`Mutex`를 획득한 스레드에서 패닉이 발생하면, 데이터가 올바르지 않은 상황이 "
+"될 수 있습니다. 이를 `Mutex`가 \"중독(poisoned)\" 되었다고 표현하며, 중독된 "
+"뮤텍스에서 `lock()`을 호출하면 실패하고 [`PoisonError`](https://doc.rust-"
+"lang.org/std/sync/struct.PoisonError.html)가 발생합니다. 이러한 오류로부터 데"
+"이터를 복구하기 위해 `into_inner()`를 호출할 수 있습니다."
+
+#: src/concurrency/shared_state/example.md:3
+msgid "Let us see `Arc` and `Mutex` in action:"
+msgstr "`Arc`와 `Mutex`의 동작을 살펴봅시다:"
+
+#: src/concurrency/shared_state/example.md:5
+#, fuzzy
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::thread;\n"
+"// use std::sync::{Arc, Mutex};\n"
+"\n"
+"fn main() {\n"
+"    let v = vec![10, 20, 30];\n"
+"    let handle = thread::spawn(|| {\n"
+"        v.push(10);\n"
+"    });\n"
+"    v.push(1000);\n"
+"\n"
+"    handle.join().unwrap();\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::sync::{Arc, Mutex};\n"
+"use std::thread;\n"
+"\n"
+"fn main() {\n"
+"    let v = Arc::new(Mutex::new(vec![10, 20, 30]));\n"
+"\n"
+"    let v2 = Arc::clone(&v);\n"
+"    let handle = thread::spawn(move || {\n"
+"        let mut v2 = v2.lock().unwrap();\n"
+"        v2.push(10);\n"
+"    });\n"
+"\n"
+"    {\n"
+"        let mut v = v.lock().unwrap();\n"
+"        v.push(1000);\n"
+"    }\n"
+"\n"
+"    handle.join().unwrap();\n"
+"\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+
+#: src/concurrency/shared_state/example.md:23
+msgid "Possible solution:"
+msgstr "가능한 해결책:"
+
+#: src/concurrency/shared_state/example.md:25
+msgid ""
+"```rust,editable\n"
+"use std::sync::{Arc, Mutex};\n"
+"use std::thread;\n"
+"\n"
+"fn main() {\n"
+"    let v = Arc::new(Mutex::new(vec![10, 20, 30]));\n"
+"\n"
+"    let v2 = Arc::clone(&v);\n"
+"    let handle = thread::spawn(move || {\n"
+"        let mut v2 = v2.lock().unwrap();\n"
+"        v2.push(10);\n"
+"    });\n"
+"\n"
+"    {\n"
+"        let mut v = v.lock().unwrap();\n"
+"        v.push(1000);\n"
+"    }\n"
+"\n"
+"    handle.join().unwrap();\n"
+"\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::sync::{Arc, Mutex};\n"
+"use std::thread;\n"
+"\n"
+"fn main() {\n"
+"    let v = Arc::new(Mutex::new(vec![10, 20, 30]));\n"
+"\n"
+"    let v2 = Arc::clone(&v);\n"
+"    let handle = thread::spawn(move || {\n"
+"        let mut v2 = v2.lock().unwrap();\n"
+"        v2.push(10);\n"
+"    });\n"
+"\n"
+"    {\n"
+"        let mut v = v.lock().unwrap();\n"
+"        v.push(1000);\n"
+"    }\n"
+"\n"
+"    handle.join().unwrap();\n"
+"\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+
+#: src/concurrency/shared_state/example.md:49
+msgid "Notable parts:"
+msgstr "눈여겨 볼 부분:"
+
+#: src/concurrency/shared_state/example.md:51
+msgid ""
+"`v` is wrapped in both `Arc` and `Mutex`, because their concerns are "
+"orthogonal."
+msgstr ""
+"`v`는 `Arc`와 `Mutex` 모두에 포함되어 있습니다. 이는 `Arc`와 `Mutex`가 서로 "
+"완전히 다른 문제를 위한 도구이기 때문입니다."
+
+#: src/concurrency/shared_state/example.md:52
+msgid ""
+"Wrapping a `Mutex` in an `Arc` is a common pattern to share mutable state "
+"between threads."
+msgstr ""
+"`Mutex`를 `Arc`로 래핑하는 것은 가변 상태를 스레드들 간에 공유할 때 흔히 사용"
+"하는 패턴입니다."
+
+#: src/concurrency/shared_state/example.md:53
+msgid ""
+"`v: Arc<_>` needs to be cloned as `v2` before it can be moved into another "
+"thread. Note `move` was added to the lambda signature."
+msgstr ""
+"`v: Arc<_>`를 다른 스레드에서 사용하려면, 먼저 `v2`로 복사를 하고 이를 그 스"
+"레드로 이동 해야 합니다. 그래서 람다의 시그니처에 `move`가 있는 것입니다."
+
+#: src/concurrency/shared_state/example.md:54
+msgid ""
+"Blocks are introduced to narrow the scope of the `LockGuard` as much as "
+"possible."
+msgstr "블록은 `LockGuard`의 범위를 최대한 좁히기 위해 사용되었습니다."
+
+#: src/exercises/concurrency/morning.md:3
+msgid "Let us practice our new concurrency skills with"
+msgstr "동시성 기법들을 연습해 봅시다"
+
+#: src/exercises/concurrency/morning.md:5
+msgid "Dining philosophers: a classic problem in concurrency."
+msgstr "식사하는 철학자 문제: 고적적인 동시성 문제입니다."
+
+#: src/exercises/concurrency/morning.md:7
+msgid ""
+"Multi-threaded link checker: a larger project where you'll use Cargo to "
+"download dependencies and then check links in parallel."
+msgstr ""
+"멀티 스레드 링크 검사기: 병렬적으로 웹페이지의 링크들을 체크합니다. 카고를 통"
+"해 몇 가지 의존성들을 다운도르 받아야 하는 큰 프로젝트 입니다."
+
+#: src/exercises/concurrency/dining-philosophers.md:3
+msgid "The dining philosophers problem is a classic problem in concurrency:"
+msgstr "식사하는 철학자 문제는 동시성에 있어서 고전적인 문제입니다:"
+
+#: src/exercises/concurrency/dining-philosophers.md:5
+msgid ""
+"Five philosophers dine together at the same table. Each philosopher has "
+"their own place at the table. There is a fork between each plate. The dish "
+"served is a kind of spaghetti which has to be eaten with two forks. Each "
+"philosopher can only alternately think and eat. Moreover, a philosopher can "
+"only eat their spaghetti when they have both a left and right fork. Thus two "
+"forks will only be available when their two nearest neighbors are thinking, "
+"not eating. After an individual philosopher finishes eating, they will put "
+"down both forks."
+msgstr ""
+"5명의 철학자가 원탁에서 식사를 하고 있습니다.  철학자는 원탁에서 자신의 자리"
+"에 앉아있습니다. 포크는 각 접시 사이에 있습니다.  제공되는 요리를 먹기 위해서"
+"는 두 개의 포크를 모두 사용해야합니다. 철학자는 생각을 하다가 배가 고프면 자"
+"신의 좌,우의 포크를 들어 요리를 먹습니다. 철학자는 요리를 먹은 후에는 포크를 "
+"다시 자리에 내려놓습니다. 철학자는 자신의 좌,우에 포크가 있을때만 요리를 먹"
+"을 수 있습니다. 따라서 두 개의 포크는 오직 자신의 좌,우 철학자가 생각을 할 때"
+"만 사용할 수 있습니다."
+
+#: src/exercises/concurrency/dining-philosophers.md:13
+#, fuzzy
+msgid ""
+"You will need a local [Cargo installation](../../cargo/running-locally.md) "
+"for this exercise. Copy the code below to a file called `src/main.rs`, fill "
+"out the blanks, and test that `cargo run` does not deadlock:"
+msgstr ""
+"이번 훈련에서는 [카고 설치하기](../../cargo/running-locally.md)가 필요합니"
+"다. 아래 코드를 복사해서 `src/main.rs`에 붙여놓고 빈 부분을 채우고, `cargo "
+"run` 커맨드로 테스트 해서 교착상태(데드락)가 발생하지 않는지 확인합니다:"
+
+#: src/exercises/concurrency/dining-philosophers.md:19
+msgid ""
+"```rust,compile_fail\n"
+"use std::sync::{mpsc, Arc, Mutex};\n"
+"use std::thread;\n"
+"use std::time::Duration;\n"
+"\n"
+"struct Fork;\n"
+"\n"
+"struct Philosopher {\n"
+"    name: String,\n"
+"    // left_fork: ...\n"
+"    // right_fork: ...\n"
+"    // thoughts: ...\n"
+"}\n"
+"\n"
+"impl Philosopher {\n"
+"    fn think(&self) {\n"
+"        self.thoughts\n"
+"            .send(format!(\"Eureka! {} has a new idea!\", &self.name))\n"
+"            .unwrap();\n"
+"    }\n"
+"\n"
+"    fn eat(&self) {\n"
+"        // Pick up forks...\n"
+"        println!(\"{} is eating...\", &self.name);\n"
+"        thread::sleep(Duration::from_millis(10));\n"
+"    }\n"
+"}\n"
+"\n"
+"static PHILOSOPHERS: &[&str] =\n"
+"    &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];\n"
+"\n"
+"fn main() {\n"
+"    // Create forks\n"
+"\n"
+"    // Create philosophers\n"
+"\n"
+"    // Make each of them think and eat 100 times\n"
+"\n"
+"    // Output their thoughts\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers.md:61
+msgid "You can use the following `Cargo.toml`:"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers.md:65
+msgid ""
+"```toml\n"
+"[package]\n"
+"name = \"dining-philosophers\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/link-checker.md:3
+msgid ""
+"Let us use our new knowledge to create a multi-threaded link checker. It "
+"should start at a webpage and check that links on the page are valid. It "
+"should recursively check other pages on the same domain and keep doing this "
+"until all pages have been validated."
+msgstr ""
+"새로 배운것들을 활용해서 멀티 스레드 링크 검사기를 만듭니다. 이 검사기는 웹페"
+"이지 안에 있는 링크들이 유효한지 확인합니다. 그리고 재귀적으로 동일 도메인의 "
+"다른 모든 페이지가 유효한지 확인합니다."
+
+#: src/exercises/concurrency/link-checker.md:8
+msgid ""
+"For this, you will need an HTTP client such as [`reqwest`](https://docs.rs/"
+"reqwest/). Create a new Cargo project and `reqwest` it as a dependency with:"
+msgstr ""
+"이를 위해서 [`reqwest`](https://docs.rs/reqwest/)와 같은 HTTP 클라이언트가 필"
+"요합니다. 새로운 로컬 프로젝트를 만들고 [`reqwest`](https://docs.rs/reqwest/)"
+"를 의존성에 추가하십시요:"
+
+#: src/exercises/concurrency/link-checker.md:11
+#, fuzzy
+msgid ""
+"```shell\n"
+"cargo new link-checker\n"
+"cd link-checker\n"
+"cargo add --features blocking,rustls-tls reqwest\n"
+"```"
+msgstr ""
+"```shell\n"
+"cargo init concurrency\n"
+"cd concurrency\n"
+"cargo add tokio --features full\n"
+"cargo run\n"
+"```"
+
+#: src/exercises/concurrency/link-checker.md:17
+msgid ""
+"If `cargo add` fails with `error: no such subcommand`, then please edit the "
+"`Cargo.toml` file by hand. Add the dependencies listed below."
+msgstr ""
+"만일 `cargo add` 커맨드가 `error: no such subcommand` 로 실패한다면 `Cargo."
+"toml` 파일을 직접 수정해도 됩니다. 아래에 전체 의존성 내용이 있습니다."
+
+#: src/exercises/concurrency/link-checker.md:20
+msgid ""
+"You will also need a way to find links. We can use [`scraper`](https://docs."
+"rs/scraper/) for that:"
+msgstr "링크를 찾기 위해서 [`scraper`](https://docs.rs/scraper/)도 추가합니다:"
+
+#: src/exercises/concurrency/link-checker.md:22
+#, fuzzy
+msgid ""
+"```shell\n"
+"cargo add scraper\n"
+"```"
+msgstr ""
+"```sh\n"
+"cargo embed --bin pac\n"
+"```"
+
+#: src/exercises/concurrency/link-checker.md:26
+msgid ""
+"Finally, we'll need some way of handling errors. We use [`thiserror`]"
+"(https://docs.rs/thiserror/) for that:"
+msgstr ""
+"마지막으로 오류 처리하는 방법으로 [`thiserror`](https://docs.rs/thiserror/)"
+"도 추가합니다:"
+
+#: src/exercises/concurrency/link-checker.md:29
+#, fuzzy
+msgid ""
+"```shell\n"
+"cargo add thiserror\n"
+"```"
+msgstr ""
+"```sh\n"
+"cargo embed --bin mmio\n"
+"```"
+
+#: src/exercises/concurrency/link-checker.md:33
+msgid ""
+"The `cargo add` calls will update the `Cargo.toml` file to look like this:"
+msgstr "모든 `cargo add`가 끝나면 `Cargo.toml`에 아래 내용이 추가됩니다:"
+
+#: src/exercises/concurrency/link-checker.md:37
+msgid ""
+"```toml\n"
+"[package]\n"
+"name = \"link-checker\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"publish = false\n"
+"\n"
+"[dependencies]\n"
+"reqwest = { version = \"0.11.12\", features = [\"blocking\", \"rustls-"
+"tls\"] }\n"
+"scraper = \"0.13.0\"\n"
+"thiserror = \"1.0.37\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/link-checker.md:50
+msgid ""
+"You can now download the start page. Try with a small site such as `https://"
+"www.google.org/`."
+msgstr "이제 `https://www.google.org/` 같은 웹 페이지를 탐색할 수 있습니다."
+
+#: src/exercises/concurrency/link-checker.md:53
+msgid "Your `src/main.rs` file should look something like this:"
+msgstr "`rc/main.rs`파일은 아래와 같습니다:"
+
+#: src/exercises/concurrency/link-checker.md:57
+msgid ""
+"```rust,compile_fail\n"
+"use reqwest::{blocking::Client, Url};\n"
+"use scraper::{Html, Selector};\n"
+"use thiserror::Error;\n"
+"\n"
+"#[derive(Error, Debug)]\n"
+"enum Error {\n"
+"    #[error(\"request error: {0}\")]\n"
+"    ReqwestError(#[from] reqwest::Error),\n"
+"    #[error(\"bad http response: {0}\")]\n"
+"    BadResponse(String),\n"
+"}\n"
+"\n"
+"#[derive(Debug)]\n"
+"struct CrawlCommand {\n"
+"    url: Url,\n"
+"    extract_links: bool,\n"
+"}\n"
+"\n"
+"fn visit_page(client: &Client, command: &CrawlCommand) -> Result<Vec<Url>, "
+"Error> {\n"
+"    println!(\"Checking {:#}\", command.url);\n"
+"    let response = client.get(command.url.clone()).send()?;\n"
+"    if !response.status().is_success() {\n"
+"        return Err(Error::BadResponse(response.status().to_string()));\n"
+"    }\n"
+"\n"
+"    let mut link_urls = Vec::new();\n"
+"    if !command.extract_links {\n"
+"        return Ok(link_urls);\n"
+"    }\n"
+"\n"
+"    let base_url = response.url().to_owned();\n"
+"    let body_text = response.text()?;\n"
+"    let document = Html::parse_document(&body_text);\n"
+"\n"
+"    let selector = Selector::parse(\"a\").unwrap();\n"
+"    let href_values = document\n"
+"        .select(&selector)\n"
+"        .filter_map(|element| element.value().attr(\"href\"));\n"
+"    for href in href_values {\n"
+"        match base_url.join(href) {\n"
+"            Ok(link_url) => {\n"
+"                link_urls.push(link_url);\n"
+"            }\n"
+"            Err(err) => {\n"
+"                println!(\"On {base_url:#}: ignored unparsable {href:?}: "
+"{err}\");\n"
+"            }\n"
+"        }\n"
+"    }\n"
+"    Ok(link_urls)\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let client = Client::new();\n"
+"    let start_url = Url::parse(\"https://www.google.org\").unwrap();\n"
+"    let crawl_command = CrawlCommand{ url: start_url, extract_links: "
+"true };\n"
+"    match visit_page(&client, &crawl_command) {\n"
+"        Ok(links) => println!(\"Links: {links:#?}\"),\n"
+"        Err(err) => println!(\"Could not extract links: {err:#}\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/link-checker.md:120
+msgid "Run the code in `src/main.rs` with"
+msgstr "아래 커맨드로 소스를 실행합니다"
+
+#: src/exercises/concurrency/link-checker.md:122
+#, fuzzy
+msgid ""
+"```shell\n"
+"cargo run\n"
+"```"
+msgstr ""
+"```sh\n"
+"cargo embed --bin pac\n"
+"```"
+
+#: src/exercises/concurrency/link-checker.md:128
+msgid ""
+"Use threads to check the links in parallel: send the URLs to be checked to a "
+"channel and let a few threads check the URLs in parallel."
+msgstr ""
+"스레드를 사용하여 링크를 병렬로 확인합니다: URL을 채널로 보내서 몇 개의 스레"
+"드가 URL을 병렬로 체크하도록 합니다."
+
+#: src/exercises/concurrency/link-checker.md:130
+msgid ""
+"Extend this to recursively extract links from all pages on the `www.google."
+"org` domain. Put an upper limit of 100 pages or so so that you don't end up "
+"being blocked by the site."
+msgstr ""
+"`www.google.org`도메인의 모든 페이지를 재귀적으로 확인하기 위해 코드를 확장해"
+"서 작성합니다: 차단당하지 않도록 100페이지 정도로 제한을 두시기 바랍니다."
+
+#: src/async.md:1
+#, fuzzy
+msgid "Async Rust"
+msgstr "비동기"
+
+#: src/async.md:3
+msgid ""
+"\"Async\" is a concurrency model where multiple tasks are executed "
+"concurrently by executing each task until it would block, then switching to "
+"another task that is ready to make progress. The model allows running a "
+"larger number of tasks on a limited number of threads. This is because the "
+"per-task overhead is typically very low and operating systems provide "
+"primitives for efficiently identifying I/O that is able to proceed."
+msgstr ""
+"\"Async\"는 블럭될(더 이상 진행할 수 없을) 때까지 각 작업을 실행한 다음 진행"
+"할 준비가 된 다른 작업으로 전환하여 여러 작업을 동시에 실행하는 동시 실행 모"
+"델입니다. 이 모델을 사용하면 제한된 수의 스레드에서 더 많은 작업을 실행할 수 "
+"있습니다. 이는, 한 작업을 유지하고 수행하는데 필요한 오버헤드가 (스레드에 비"
+"해) 매우 낮고 운영체제가 여러 I/O들에서 현재 진행 가능한 I/O들을 효과적으로 "
+"식별해 주는 프리미티브를 제공하기 때문입니다."
+
+#: src/async.md:10
+msgid ""
+"Rust's asynchronous operation is based on \"futures\", which represent work "
+"that may be completed in the future. Futures are \"polled\" until they "
+"signal that they are complete."
+msgstr ""
+"Rust의 비동기 작업은 \"futures\"를 기반으로 하며 이는 미래에 완료될 수 있는 "
+"작업을 나타냅니다. Futures는 완료되었다는 신호를 보낼 때까지 \"폴링\"됩니다."
+
+#: src/async.md:14
+msgid ""
+"Futures are polled by an async runtime, and several different runtimes are "
+"available."
+msgstr ""
+"Futures는 비동기 런타임에 의해 폴링되며, 비동기 런타임에는 여러 다양한 종류"
+"가 있습니다."
+
+#: src/async.md:17
+#, fuzzy
+msgid "Comparisons"
+msgstr "비교"
+
+#: src/async.md:19
+msgid ""
+"Python has a similar model in its `asyncio`. However, its `Future` type is "
+"callback-based, and not polled. Async Python programs require a \"loop\", "
+"similar to a runtime in Rust."
+msgstr ""
+"파이썬에도 `asyncio`라는 유사한 모델이 있습니다. 그러나 파이썬의 `Future` 타"
+"입은 콜백 기반이며 폴링되지 않습니다. 파이썬으로 비동기 프로그래밍을 할 때에"
+"는, Rust에서 런타임이 내부적으로 해 주는 것과 유사한,  \"루프\"를 명시적으로 "
+"사용해야 합니다."
+
+#: src/async.md:23
+msgid ""
+"JavaScript's `Promise` is similar, but again callback-based. The language "
+"runtime implements the event loop, so many of the details of Promise "
+"resolution are hidden."
+msgstr ""
+"자바스크립트의 `Promise`도 비슷하지만 역시 콜백 기반입니다. 자바스크립트에서"
+"는 이벤트 루프가런타임 엔진에서 구현되므로 `Promise`가 처리되는 세부 과정이 "
+"숨겨집니다."
+
+#: src/async/async-await.md:1
+msgid "`async`/`await`"
+msgstr "`async`/`await`"
+
+#: src/async/async-await.md:3
+msgid ""
+"At a high level, async Rust code looks very much like \"normal\" sequential "
+"code:"
+msgstr ""
+"겉에서 보았을 때, 비동기 Rust 코드는 일반적인 절차적 코드와 매우 유사합니다."
+
+#: src/async/async-await.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use futures::executor::block_on;\n"
+"\n"
+"async fn count_to(count: i32) {\n"
+"    for i in 1..=count {\n"
+"        println!(\"Count is: {i}!\");\n"
+"    }\n"
+"}\n"
+"\n"
+"async fn async_main(count: i32) {\n"
+"    count_to(count).await;\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    block_on(async_main(10));\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use futures::executor::block_on;\n"
+"\n"
+"async fn count_to(count: i32) {\n"
+"    for i in 1..=count {\n"
+"        println!(\"Count is: {i}!\");\n"
+"    }\n"
+"}\n"
+"\n"
+"async fn async_main(count: i32) {\n"
+"    count_to(count).await;\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    block_on(async_main(10));\n"
+"}\n"
+"```"
+
+#: src/async/async-await.md:27
+msgid ""
+"Note that this is a simplified example to show the syntax. There is no long "
+"running operation or any real concurrency in it!"
+msgstr ""
+"Rust 비동기 문법을 보여주는 간단한 예시입니다. 여기에는 오래 실행되는 작업이"
+"나, 실제로 동시에 수행되는 것들은 없습니다."
+
+#: src/async/async-await.md:30
+msgid "What is the return type of an async call?"
+msgstr "`async`함수의 리턴 타입은 무엇인가요?"
+
+#: src/async/async-await.md:31
+msgid "Use `let future: () = async_main(10);` in `main` to see the type."
+msgstr ""
+"`main`에서 \\`let future: () = async_main(10);을 사용하여 타입을 확인하세요."
+
+#: src/async/async-await.md:33
+msgid ""
+"The \"async\" keyword is syntactic sugar. The compiler replaces the return "
+"type with a future. "
+msgstr ""
+"\"async\" 키워드는 문법 설탕(syntactic sugar)입니다. 컴파일러가 리턴 타입을 "
+"future로 바꿉니다. "
+
+#: src/async/async-await.md:36
+msgid ""
+"You cannot make `main` async, without additional instructions to the "
+"compiler on how to use the returned future."
+msgstr ""
+"`main`을 비동기 함수로 만들수는 없습니다. 만약 그렇게 할 경우 컴파일러는 리"
+"턴 타입인 future를 어떻게 사용할 지 모르기 때문입니다."
+
+#: src/async/async-await.md:39
+msgid ""
+"You need an executor to run async code. `block_on` blocks the current thread "
+"until the provided future has run to completion. "
+msgstr ""
+"비동기 코드를 실행하려면 실행자(executor)가 필요합니다. `block_on` 실행자는 "
+"제공된 future가 완료될 때까지 현재 스레드를 블록합니다. "
+
+#: src/async/async-await.md:42
+msgid ""
+"`.await` asynchronously waits for the completion of another operation. "
+"Unlike `block_on`, `.await` doesn't block the current thread."
+msgstr ""
+"`.await`는 다른 작업이 완료될 때까지 비동기적으로 대기합니다. `block_on`과 달"
+"리 `.await`는 현재 스레드를 블록하지 않습니다."
+
+#: src/async/async-await.md:45
+msgid ""
+"`.await` can only be used inside an `async` function (or block; these are "
+"introduced later). "
+msgstr ""
+"`.await`는 `async` 함수(또는 나중에 소개될 `async` 블록) 안에서만 사용할 수 "
+"있습니다. "
+
+#: src/async/futures.md:3
+msgid ""
+"[`Future`](https://doc.rust-lang.org/std/future/trait.Future.html) is a "
+"trait, implemented by objects that represent an operation that may not be "
+"complete yet. A future can be polled, and `poll` returns a [`Poll`](https://"
+"doc.rust-lang.org/std/task/enum.Poll.html)."
+msgstr ""
+"[`Future`](https://doc.rust-lang.org/std/future/trait.Future.html)는 트레잇입"
+"니다.이 트레잇은 아직 완료되지 않았을 수도 있는 작업을 나타냅니다. Future는 "
+"`poll` 함수를 통해 폴링될 수 있으며, 이 함수는 [`Poll`](https://doc.rust-"
+"lang.org/std/task/enum.Poll.html)을 반환합니다."
+
+#: src/async/futures.md:8
+msgid ""
+"```rust\n"
+"use std::pin::Pin;\n"
+"use std::task::Context;\n"
+"\n"
+"pub trait Future {\n"
+"    type Output;\n"
+"    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::"
+"Output>;\n"
+"}\n"
+"\n"
+"pub enum Poll<T> {\n"
+"    Ready(T),\n"
+"    Pending,\n"
+"}\n"
+"```"
+msgstr ""
+"```rust\n"
+"use std::pin::Pin;\n"
+"use std::task::Context;\n"
+"\n"
+"pub trait Future {\n"
+"    type Output;\n"
+"    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::"
+"Output>;\n"
+"}\n"
+"\n"
+"pub enum Poll<T> {\n"
+"    Ready(T),\n"
+"    Pending,\n"
+"}\n"
+"```"
+
+#: src/async/futures.md:23
+msgid ""
+"An async function returns an `impl Future`. It's also possible (but "
+"uncommon) to implement `Future` for your own types. For example, the "
+"`JoinHandle` returned from `tokio::spawn` implements `Future` to allow "
+"joining to it."
+msgstr ""
+"비동기 함수는 `impl Future`를 반환합니다. 새로운 타입을 만들고 이 타입이 "
+"`Future`를 구현하게 할 수도 있지만 일반적이지는 않습니다. 예를 들어 `tokio::"
+"spawn`가 리턴하는 `JoinHandle`은 `Future`를 구현하며, 이를 통해 생성된 스레드"
+"에 join할 수 있습니다."
+
+#: src/async/futures.md:27
+msgid ""
+"The `.await` keyword, applied to a Future, causes the current async function "
+"to pause until that Future is ready, and then evaluates to its output."
+msgstr ""
+"Future에 `.await`를 호출하면, 해당 Future가 준비될 때까지 현재 비동기 함수가 "
+"일시 중지됩니다. 그런 다음 Future가 준비가 되면, 그 값이 `.await` 구문의 값"
+"이 됩니다."
+
+#: src/async/futures.md:32
+msgid ""
+"The `Future` and `Poll` types are implemented exactly as shown; click the "
+"links to show the implementations in the docs."
+msgstr ""
+"`Future` 와 `Poll` 타입의 실제 정의는 위에 보이는 그대로 입니다. 링크를 클릭"
+"하면 Rust 문서에서 한 번 더 확인할 수 있습니다."
+
+#: src/async/futures.md:35
+msgid ""
+"We will not get to `Pin` and `Context`, as we will focus on writing async "
+"code, rather than building new async primitives. Briefly:"
+msgstr ""
+"본 강의의 목적은 비동기 코드를 작성하는데 있기 때문에, 새로운 비동기 프리미티"
+"브를 만드는데 필요한  `Pin`과 `Context`는 다루지 않습니다. 이들에 대해 간단"
+"히 설명하자면:"
+
+#: src/async/futures.md:38
+msgid ""
+"`Context` allows a Future to schedule itself to be polled again when an "
+"event occurs."
+msgstr ""
+"`Context`를 사용하면 Future가 이벤트가 발생할 때 다시 폴링되도록 예약할 수 있"
+"습니다."
+
+#: src/async/futures.md:41
+msgid ""
+"`Pin` ensures that the Future isn't moved in memory, so that pointers into "
+"that future remain valid. This is required to allow references to remain "
+"valid after an `.await`."
+msgstr ""
+"'Pin'을 사용하면 메모리에서 Future의 위치가 고정되기 때문에 해당 future의 포"
+"인터가 항상 유효하게 유지됩니다. 이는 `.await` 후에 참조를 유효한 상태로 유지"
+"하기 위해 필요합니다."
+
+#: src/async/runtimes.md:3
+msgid ""
+"A _runtime_ provides support for performing operations asynchronously (a "
+"_reactor_) and is responsible for executing futures (an _executor_). Rust "
+"does not have a \"built-in\" runtime, but several options are available:"
+msgstr ""
+"비동기 _런타임_은 _리액터_ (비동기식 작업 실행을 지원)와 _실행자_ (futures를 "
+"실행)의 두 가지 역할을 합니다. Rust 언어 자체에서 기본 제공하는 비동기 런타임"
+"은 없습니다. 그러나 다음과 같은 비동기 런타임 크레잇들이 있습니다."
+
+#: src/async/runtimes.md:7
+#, fuzzy
+msgid ""
+"[Tokio](https://tokio.rs/): performant, with a well-developed ecosystem of "
+"functionality like [Hyper](https://hyper.rs/) for HTTP or [Tonic](https://"
+"github.com/hyperium/tonic) for gRPC."
+msgstr ""
+"[Tokio](https://tokio.rs/) - 성능이 우수합니다. 그리고 HTTP를 지원하는 "
+"[Hyper](https://hyper.rs/) 와 gRPC를 지원하는 [Tonic](https://github.com/"
+"hyperium/tonic)과 같은 잘 발달된 라이브러리 생태계가 있습니다."
+
+#: src/async/runtimes.md:10
+#, fuzzy
+msgid ""
+"[async-std](https://async.rs/): aims to be a \"std for async\", and includes "
+"a basic runtime in `async::task`."
+msgstr ""
+"[async-std](https://async.rs/) - 비동기에서의 `std`를 목표로 하고 있습니다. "
+"`async::task`에 기본 런타임이 포함되어 있습니다."
+
+#: src/async/runtimes.md:12
+#, fuzzy
+msgid "[smol](https://docs.rs/smol/latest/smol/): simple and lightweight"
+msgstr "[smol](https://docs.rs/smol/latest/smol/) - 간단하고 가볍습니다."
+
+#: src/async/runtimes.md:14
+msgid ""
+"Several larger applications have their own runtimes. For example, [Fuchsia]"
+"(https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/src/lib/fuchsia-"
+"async/src/lib.rs) already has one."
+msgstr ""
+"여러 대규모 애플리케이션에는 자체 런타임이 있는 경우도 있습니다. 예들 들어  "
+"[Fuchsia](https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/src/lib/"
+"fuchsia-async/src/lib.rs)가 있습니다."
+
+#: src/async/runtimes.md:20
+msgid ""
+"Note that of the listed runtimes, only Tokio is supported in the Rust "
+"playground. The playground also does not permit any I/O, so most interesting "
+"async things can't run in the playground."
+msgstr ""
+"Rust 플레이그라운드에서는 위에 나열된 비동기 런타임 중에서 Tokio만 사용할 수 "
+"있습니다. 또한 Rust 플레이그라운드는 I/O를 허용하지 않으므로 async를 가지고 "
+"할 수 있는 많은 흥미로운 작업들이 불가능 합니다."
+
+#: src/async/runtimes.md:24
+msgid ""
+"Futures are \"inert\" in that they do not do anything (not even start an I/O "
+"operation) unless there is an executor polling them. This differs from JS "
+"Promises, for example, which will run to completion even if they are never "
+"used."
+msgstr ""
+"Futures는 실행자가 폴링하지 않는 한 아무것도 하지 않는다는 점에서(I/O 작업조"
+"차 시작하지 않음) \"비활성\" 상태입니다. 이는 사용되지 않는 경우에도 완료될 "
+"때 까지 실행되는, 자바 스크립트의 promise와 다릅니다."
+
+#: src/async/runtimes/tokio.md:4
+msgid "Tokio provides: "
+msgstr "Tokio는 다음을 제공합니다. "
+
+#: src/async/runtimes/tokio.md:6
+msgid "A multi-threaded runtime for executing asynchronous code."
+msgstr "비동기 코드 실행을 위한 멀티스레드 런타임"
+
+#: src/async/runtimes/tokio.md:7
+msgid "An asynchronous version of the standard library."
+msgstr "표준 라이브러리의 비동기 버전"
+
+#: src/async/runtimes/tokio.md:8
+msgid "A large ecosystem of libraries."
+msgstr "대규모 라이브러리 생태계"
+
+#: src/async/runtimes/tokio.md:10
+msgid ""
+"```rust,editable,compile_fail\n"
+"use tokio::time;\n"
+"\n"
+"async fn count_to(count: i32) {\n"
+"    for i in 1..=count {\n"
+"        println!(\"Count in task: {i}!\");\n"
+"        time::sleep(time::Duration::from_millis(5)).await;\n"
+"    }\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    tokio::spawn(count_to(10));\n"
+"\n"
+"    for i in 1..5 {\n"
+"        println!(\"Main task: {i}\");\n"
+"        time::sleep(time::Duration::from_millis(5)).await;\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use tokio::time;\n"
+"\n"
+"async fn count_to(count: i32) {\n"
+"    for i in 1..=count {\n"
+"        println!(\"Count in task: {i}!\");\n"
+"        time::sleep(time::Duration::from_millis(5)).await;\n"
+"    }\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    tokio::spawn(count_to(10));\n"
+"\n"
+"    for i in 1..5 {\n"
+"        println!(\"Main task: {i}\");\n"
+"        time::sleep(time::Duration::from_millis(5)).await;\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/async/runtimes/tokio.md:33
+msgid "With the `tokio::main` macro we can now make `main` async."
+msgstr ""
+"이제 `tokio::main` 매크로를 사용하면 `main`을 비동기로 만들 수 있습니다."
+
+#: src/async/runtimes/tokio.md:35
+msgid "The `spawn` function creates a new, concurrent \"task\"."
+msgstr "`spawn` 함수는 동시 실행되는 새로운 \"작업\"을 만듭니다."
+
+#: src/async/runtimes/tokio.md:37
+msgid "Note: `spawn` takes a `Future`, you don't call `.await` on `count_to`."
+msgstr ""
+"참고: `spawn`은 `Future`를 인자로 받습니다. 때문에 `count_to`에 `.await`를 호"
+"출하지 않는 점을 주목하세요."
+
+#: src/async/runtimes/tokio.md:39
+msgid "**Further exploration:**"
+msgstr "**심화 학습:**"
+
+#: src/async/runtimes/tokio.md:41
+msgid ""
+"Why does `count_to` not (usually) get to 10? This is an example of async "
+"cancellation. `tokio::spawn` returns a handle which can be awaited to wait "
+"until it finishes."
+msgstr ""
+"`count_to`가 10에 도달하지 않는 경우가 많은데 그 이유는 무엇일까요? 이는 비동"
+"기적인 취소를 보여주는 예입니다. `tokio::spawn`이 리턴하는 것은 완료될 때까"
+"지 기다리도록 대기하는데 사용되는 핸들입니다."
+
+#: src/async/runtimes/tokio.md:45
+msgid "Try `count_to(10).await` instead of spawning."
+msgstr "`tokio::spawn` 대신 `count_to(10).await`를 사용해 보세요."
+
+#: src/async/runtimes/tokio.md:47
+msgid "Try awaiting the task returned from `tokio::spawn`."
+msgstr "`tokio::spawn`에서 반환된 작업을 `await` 해 보세요."
+
+#: src/async/tasks.md:3
+msgid "Rust has a task system, which is a form of lightweight threading."
+msgstr "Rust의 태스크(작업) 시스템은 경량 스레딩의 한 종류로 볼 수 있습니다."
+
+#: src/async/tasks.md:5
+msgid ""
+"A task has a single top-level future which the executor polls to make "
+"progress. That future may have one or more nested futures that its `poll` "
+"method polls, corresponding loosely to a call stack. Concurrency within a "
+"task is possible by polling multiple child futures, such as racing a timer "
+"and an I/O operation."
+msgstr ""
+"하나의 작업에는, 실행자가 이 작업을 진행하기 위해 계속 폴링하는, 최상위 "
+"future가 한 개 있습니다. 이 future에는 `poll` 메서드가 폴링하는 중첩된 future"
+"가 한 개 이상 있을 수 있습니다. 이러한 중첩된 future는 일반적인 함수 호출 스"
+"택하고 비슷한 역할을 합니다. 한 작업 안에서 여러 자식 future들을 폴링하면, 타"
+"이머를 켜는 것과 어떤 I/O작업을 동시에 수행시킨 후 타이머와 I/O 중 먼저 끝나"
+"는 것을 기다리는 것과 같은동시성도 구현할 수 있습니다."
+
+#: src/async/tasks.md:10
+msgid ""
+"```rust,compile_fail\n"
+"use tokio::io::{self, AsyncReadExt, AsyncWriteExt};\n"
+"use tokio::net::TcpListener;\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> io::Result<()> {\n"
+"    let listener = TcpListener::bind(\"127.0.0.1:6142\").await?;\n"
+"\tprintln!(\"listening on port 6142\");\n"
+"\n"
+"    loop {\n"
+"        let (mut socket, addr) = listener.accept().await?;\n"
+"\n"
+"        println!(\"connection from {addr:?}\");\n"
+"\n"
+"        tokio::spawn(async move {\n"
+"            if let Err(e) = socket.write_all(b\"Who are you?\\n\").await {\n"
+"                println!(\"socket error: {e:?}\");\n"
+"                return;\n"
+"            }\n"
+"\n"
+"            let mut buf = vec![0; 1024];\n"
+"            let reply = match socket.read(&mut buf).await {\n"
+"                Ok(n) => {\n"
+"                    let name = std::str::from_utf8(&buf[..n]).unwrap()."
+"trim();\n"
+"                    format!(\"Thanks for dialing in, {name}!\\n\")\n"
+"                }\n"
+"                Err(e) => {\n"
+"                    println!(\"socket error: {e:?}\");\n"
+"                    return;\n"
+"                }\n"
+"            };\n"
+"\n"
+"            if let Err(e) = socket.write_all(reply.as_bytes()).await {\n"
+"                println!(\"socket error: {e:?}\");\n"
+"            }\n"
+"        });\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,compile_fail\n"
+"use tokio::io::{self, AsyncReadExt, AsyncWriteExt};\n"
+"use tokio::net::TcpListener;\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> io::Result<()> {\n"
+"    let listener = TcpListener::bind(\"127.0.0.1:6142\").await?;\n"
+"\tprintln!(\"listening on port 6142\");\n"
+"\n"
+"    loop {\n"
+"        let (mut socket, addr) = listener.accept().await?;\n"
+"\n"
+"        println!(\"connection from {addr:?}\");\n"
+"\n"
+"        tokio::spawn(async move {\n"
+"            if let Err(e) = socket.write_all(b\"Who are you?\\n\").await {\n"
+"                println!(\"socket error: {e:?}\");\n"
+"                return;\n"
+"            }\n"
+"\n"
+"            let mut buf = vec![0; 1024];\n"
+"            let reply = match socket.read(&mut buf).await {\n"
+"                Ok(n) => {\n"
+"                    let name = std::str::from_utf8(&buf[..n]).unwrap()."
+"trim();\n"
+"                    format!(\"Thanks for dialing in, {name}!\\n\")\n"
+"                }\n"
+"                Err(e) => {\n"
+"                    println!(\"socket error: {e:?}\");\n"
+"                    return;\n"
+"                }\n"
+"            };\n"
+"\n"
+"            if let Err(e) = socket.write_all(reply.as_bytes()).await {\n"
+"                println!(\"socket error: {e:?}\");\n"
+"            }\n"
+"        });\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/async/tasks.md:52 src/async/control-flow/join.md:36
+msgid ""
+"Copy this example into your prepared `src/main.rs` and run it from there."
+msgstr ""
+"이 예제를, 로컬 컴퓨터에 만들어 둔 `src/main.rs`에 복사하고 거기에서 실행하세"
+"요."
+
+#: src/async/tasks.md:54
+msgid ""
+"Ask students to visualize what the state of the example server would be with "
+"a few connected clients. What tasks exist? What are their Futures?"
+msgstr ""
+"수강생들에게 이 서버에 몇 개의 클라이언트가 연결되면 이 서버의 상태가 어떻게 "
+"변할지 그림을 그려보도록 하세요. 어떤 태스크들이 있는지, 이 태스크들의 Future"
+"는 어떤 상태에 있는지 물어봅니다."
+
+#: src/async/tasks.md:57
+msgid ""
+"This is the first time we've seen an `async` block. This is similar to a "
+"closure, but does not take any arguments. Its return value is a Future, "
+"similar to an `async fn`. "
+msgstr ""
+"`async` 블록을 처음 보게 되었습니다. 이것은 클로저와 비슷하지만 인자를 받지 "
+"않습니다. 리턴 타입은 `async fn`과 비슷한 Future입니다. "
+
+#: src/async/tasks.md:61
+msgid ""
+"Refactor the async block into a function, and improve the error handling "
+"using `?`."
+msgstr ""
+"Async 블록을 함수로 리팩터링하고 `?`를 사용하여 오류 처리를 개선해 봅시다."
+
+#: src/async/channels.md:3
+msgid ""
+"Several crates have support for asynchronous channels. For instance `tokio`:"
+msgstr ""
+"여러 크레이트에서 비동기 채널을 지원합니다. 예를 들어 `tokio`에서는 아래와 같"
+"이합니다."
+
+#: src/async/channels.md:5
+#, fuzzy
+msgid ""
+"```rust,editable,compile_fail\n"
+"use tokio::sync::mpsc::{self, Receiver};\n"
+"\n"
+"async fn ping_handler(mut input: Receiver<()>) {\n"
+"    let mut count: usize = 0;\n"
+"\n"
+"    while let Some(_) = input.recv().await {\n"
+"        count += 1;\n"
+"        println!(\"Received {count} pings so far.\");\n"
+"    }\n"
+"\n"
+"    println!(\"ping_handler complete\");\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let (sender, receiver) = mpsc::channel(32);\n"
+"    let ping_handler_task = tokio::spawn(ping_handler(receiver));\n"
+"    for i in 0..10 {\n"
+"        sender.send(()).await.expect(\"Failed to send ping.\");\n"
+"        println!(\"Sent {} pings so far.\", i + 1);\n"
+"    }\n"
+"\n"
+"    drop(sender);\n"
+"    ping_handler_task.await.expect(\"Something went wrong in ping handler "
+"task.\");\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use tokio::sync::mpsc::{self, Receiver};\n"
+"\n"
+"async fn ping_handler(mut input: Receiver<()>) {\n"
+"    let mut count: usize = 0;\n"
+"\n"
+"    while let Some(_) = input.recv().await {\n"
+"        count += 1;\n"
+"        println!(\"Received {count} pings so far.\");\n"
+"    }\n"
+"\n"
+"    println!(\"ping_handler complete\");\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let (sender, receiver) = mpsc::channel(32);\n"
+"    let ping_handler_task = tokio::spawn(ping_handler(receiver));\n"
+"    for i in 0..10 {\n"
+"        sender.send(()).await.expect(\"Failed to send ping.\");\n"
+"        println!(\"Sent {} pings so far.\", i + 1);\n"
+"    }\n"
+"\n"
+"    std::mem::drop(sender);\n"
+"    ping_handler_task.await.expect(\"Something went wrong in ping handler "
+"task.\");\n"
+"}\n"
+"```"
+
+#: src/async/channels.md:35
+msgid "Change the channel size to `3` and see how it affects the execution."
+msgstr "채널 크기를 `3`으로 변경하고 동작이 어떻게 바뀌는지 확인하세요."
+
+#: src/async/channels.md:37
+msgid ""
+"Overall, the interface is similar to the `sync` channels as seen in the "
+"[morning class](concurrency/channels.md)."
+msgstr ""
+"비동기 채널을 사용하기 위한 인터페이스는 [오전 과정](concurrency/channels.md)"
+"에서 배운 `sync` 채널과 비슷합니다."
+
+#: src/async/channels.md:40
+msgid "Try removing the `std::mem::drop` call. What happens? Why?"
+msgstr ""
+"`std::mem::drop` 호출하는 줄을 삭제해 보세요. 어떤 결과가 나타나나요? 이유가 "
+"무엇인가요?"
+
+#: src/async/channels.md:42
+msgid ""
+"The [Flume](https://docs.rs/flume/latest/flume/) crate has channels that "
+"implement both `sync` and `async` `send` and `recv`. This can be convenient "
+"for complex applications with both IO and heavy CPU processing tasks."
+msgstr ""
+"[Flume](https://docs.rs/flume/latest/flume/) 크레이트에는 `sync`와 `async`, "
+"`send`와 `recv`를 모두 구현하는 채널이 있습니다. 이것은 IO와 CPU 처리 작업이 "
+"많은 복잡한 애플리케이션을 구현할 때 매우 유용합니다."
+
+#: src/async/channels.md:46
+msgid ""
+"What makes working with `async` channels preferable is the ability to "
+"combine them with other `future`s to combine them and create complex control "
+"flow."
+msgstr ""
+"`async` 채널을 사용하는 것이 더 좋은 이유는 이를 다른 `future`와 결합하여 복"
+"잡한 제어 흐름을 만들 수 있기 때문입니다."
+
+#: src/async/control-flow.md:1
+#, fuzzy
+msgid "Futures Control Flow"
+msgstr "흐름 제어"
+
+#: src/async/control-flow.md:3
+msgid ""
+"Futures can be combined together to produce concurrent compute flow graphs. "
+"We have already seen tasks, that function as independent threads of "
+"execution."
+msgstr ""
+"Future들을 결합하여 계산 과정을 동시성이 있는 플로우 그래프 형태로 모델링 할 "
+"수 있습니다. 앞서 배운,  각 태스크가 독립적으로 수행되도록 하는 것도 Future들"
+"을 결합하는 한 방법으로 볼 수 있습니다."
+
+#: src/async/control-flow.md:6
+msgid "[Join](control-flow/join.md)"
+msgstr "[Join](control-flow/join.md)"
+
+#: src/async/control-flow.md:7
+msgid "[Select](control-flow/select.md)"
+msgstr "[Select](control-flow/select.md)"
+
+#: src/async/control-flow/join.md:3
+msgid ""
+"A join operation waits until all of a set of futures are ready, and returns "
+"a collection of their results. This is similar to `Promise.all` in "
+"JavaScript or `asyncio.gather` in Python."
+msgstr ""
+"Join 연산은 모든 future가 준비될 때까지 기다린 후, 각 future의 결과값을 담은 "
+"컬렉션을 리턴합니다. 이는 자바스크립트의 `Promise.all`이나 파이썬의 `asyncio."
+"gather`와 유사합니다."
+
+#: src/async/control-flow/join.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"use anyhow::Result;\n"
+"use futures::future;\n"
+"use reqwest;\n"
+"use std::collections::HashMap;\n"
+"\n"
+"async fn size_of_page(url: &str) -> Result<usize> {\n"
+"    let resp = reqwest::get(url).await?;\n"
+"    Ok(resp.text().await?.len())\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let urls: [&str; 4] = [\n"
+"        \"https://google.com\",\n"
+"        \"https://httpbin.org/ip\",\n"
+"        \"https://play.rust-lang.org/\",\n"
+"        \"BAD_URL\",\n"
+"    ];\n"
+"    let futures_iter = urls.into_iter().map(size_of_page);\n"
+"    let results = future::join_all(futures_iter).await;\n"
+"    let page_sizes_dict: HashMap<&str, Result<usize>> =\n"
+"        urls.into_iter().zip(results.into_iter()).collect();\n"
+"    println!(\"{:?}\", page_sizes_dict);\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use anyhow::Result;\n"
+"use futures::future;\n"
+"use reqwest;\n"
+"use std::collections::HashMap;\n"
+"\n"
+"async fn size_of_page(url: &str) -> Result<usize> {\n"
+"    let resp = reqwest::get(url).await?;\n"
+"    Ok(resp.text().await?.len())\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let urls: [&str; 4] = [\n"
+"        \"https://google.com\",\n"
+"        \"https://httpbin.org/ip\",\n"
+"        \"https://play.rust-lang.org/\",\n"
+"        \"BAD_URL\",\n"
+"    ];\n"
+"    let futures_iter = urls.into_iter().map(size_of_page);\n"
+"    let results = future::join_all(futures_iter).await;\n"
+"    let page_sizes_dict: HashMap<&str, Result<usize>> =\n"
+"        urls.into_iter().zip(results.into_iter()).collect();\n"
+"    println!(\"{:?}\", page_sizes_dict);\n"
+"}\n"
+"```"
+
+#: src/async/control-flow/join.md:38
+msgid ""
+"For multiple futures of disjoint types, you can use `std::future::join!` but "
+"you must know how many futures you will have at compile time. This is "
+"currently in the `futures` crate, soon to be stabilised in `std::future`."
+msgstr ""
+"서로 다른 타입을 가지는 여러 여러 futures들을 join하고자 할 경우 `std::"
+"future::join!`을 사용할 수 있습니다. 이 매크로를 사용하려면 futures가 몇 개"
+"나 있을지 컴파일 할 때 알아야 한다는 점을 주의하세요. 이 매크로는 지금은 "
+"'futures' 크레이트에 있으며 곧 안정화 되어 `std::future`에 포함될 예정입니다."
+
+#: src/async/control-flow/join.md:42
+msgid ""
+"The risk of `join` is that one of the futures may never resolve, this would "
+"cause your program to stall. "
+msgstr ""
+"'join'의 위험성은 futures들 중 하나가 영영 끝나지 않을 수도 있다는 것입니다. "
+"그러면 프로그램이 더이상 진행을 못하고 멈춰있을(stall) 수 있습니다. "
+
+#: src/async/control-flow/join.md:45
+msgid ""
+"You can also combine `join_all` with `join!` for instance to join all "
+"requests to an http service as well as a database query. Try adding a "
+"`tokio::time::sleep` to the future, using `futures::join!`. This is not a "
+"timeout (that requires `select!`, explained in the next chapter), but "
+"demonstrates `join!`."
+msgstr ""
+"`join_all`을 `join!`과 결합하여 http 서비스와 데이터베이스에 대한 모든 요청들"
+"을 한꺼번에 진행시킬 수도 있습니다. `futures::join!`을 사용하여 `tokio::"
+"time::sleep`을 future에 추가해 보세요. 이건 타임아웃을 구현하는 것이 아님을 "
+"주의하세요.  실제로, 타임아웃은 다음 장에서 설명하는 `select!`를 사용해서 구"
+"현해야 합니다.  여기서는 `tokio::time::sleep`을 사용한 것은 단순히 `join!`의 "
+"동작을 설명하기 위함입니다."
+
+#: src/async/control-flow/select.md:3
+msgid ""
+"A select operation waits until any of a set of futures is ready, and "
+"responds to that future's result. In JavaScript, this is similar to `Promise."
+"race`. In Python, it compares to `asyncio.wait(task_set, return_when=asyncio."
+"FIRST_COMPLETED)`."
+msgstr ""
+"Select 연산은 여러 future들 모두에 대해서 준비될 때 까지 기다리다가, 그 중 어"
+"떤 한 future가 최초로 준비 상태가 되면 해당 future의 결과값을 리턴합니다.  이"
+"것은 자바스크립트에서의 `Promise.race`와 비슷합니다. 파이썬에서라면 `asyncio."
+"wait(task_set, return_when=asyncio.FIRST_COMPLETED)`가 하는 동작과 비슷합니"
+"다."
+
+#: src/async/control-flow/select.md:8
+msgid ""
+"Similar to a match statement, the body of `select!` has a number of arms, "
+"each of the form `pattern = future => statement`. When the `future` is "
+"ready, the `statement` is executed with the variables in `pattern` bound to "
+"the `future`'s result."
+msgstr ""
+"`select!` 안에는, `match`문과 비슷하게, `pattern = future => statement` 형태"
+"의 브랜치(arm) 들이 있습니다. 어떤 'future'가 진행 가능 상태가 되면 '그 "
+"`future`의 결과값이 `pattern`으로 바인딩 되며, 그 상태에서 \\`statement'가 수"
+"행됩니다."
+
+#: src/async/control-flow/select.md:13
+msgid ""
+"```rust,editable,compile_fail\n"
+"use tokio::sync::mpsc::{self, Receiver};\n"
+"use tokio::time::{sleep, Duration};\n"
+"\n"
+"#[derive(Debug, PartialEq)]\n"
+"enum Animal {\n"
+"    Cat { name: String },\n"
+"    Dog { name: String },\n"
+"}\n"
+"\n"
+"async fn first_animal_to_finish_race(\n"
+"    mut cat_rcv: Receiver<String>,\n"
+"    mut dog_rcv: Receiver<String>,\n"
+") -> Option<Animal> {\n"
+"    tokio::select! {\n"
+"        cat_name = cat_rcv.recv() => Some(Animal::Cat { name: cat_name? }),\n"
+"        dog_name = dog_rcv.recv() => Some(Animal::Dog { name: dog_name? })\n"
+"    }\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let (cat_sender, cat_receiver) = mpsc::channel(32);\n"
+"    let (dog_sender, dog_receiver) = mpsc::channel(32);\n"
+"    tokio::spawn(async move {\n"
+"        sleep(Duration::from_millis(500)).await;\n"
+"        cat_sender\n"
+"            .send(String::from(\"Felix\"))\n"
+"            .await\n"
+"            .expect(\"Failed to send cat.\");\n"
+"    });\n"
+"    tokio::spawn(async move {\n"
+"        sleep(Duration::from_millis(50)).await;\n"
+"        dog_sender\n"
+"            .send(String::from(\"Rex\"))\n"
+"            .await\n"
+"            .expect(\"Failed to send dog.\");\n"
+"    });\n"
+"\n"
+"    let winner = first_animal_to_finish_race(cat_receiver, dog_receiver)\n"
+"        .await\n"
+"        .expect(\"Failed to receive winner\");\n"
+"\n"
+"    println!(\"Winner is {winner:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use tokio::sync::mpsc::{self, Receiver};\n"
+"use tokio::time::{sleep, Duration};\n"
+"\n"
+"#[derive(Debug, PartialEq)]\n"
+"enum Animal {\n"
+"    Cat { name: String },\n"
+"    Dog { name: String },\n"
+"}\n"
+"\n"
+"async fn first_animal_to_finish_race(\n"
+"    mut cat_rcv: Receiver<String>,\n"
+"    mut dog_rcv: Receiver<String>,\n"
+") -> Option<Animal> {\n"
+"    tokio::select! {\n"
+"        cat_name = cat_rcv.recv() => Some(Animal::Cat { name: cat_name? }),\n"
+"        dog_name = dog_rcv.recv() => Some(Animal::Dog { name: dog_name? })\n"
+"    }\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let (cat_sender, cat_receiver) = mpsc::channel(32);\n"
+"    let (dog_sender, dog_receiver) = mpsc::channel(32);\n"
+"    tokio::spawn(async move {\n"
+"        sleep(Duration::from_millis(500)).await;\n"
+"        cat_sender\n"
+"            .send(String::from(\"Felix\"))\n"
+"            .await\n"
+"            .expect(\"Failed to send cat.\");\n"
+"    });\n"
+"    tokio::spawn(async move {\n"
+"        sleep(Duration::from_millis(50)).await;\n"
+"        dog_sender\n"
+"            .send(String::from(\"Rex\"))\n"
+"            .await\n"
+"            .expect(\"Failed to send dog.\");\n"
+"    });\n"
+"\n"
+"    let winner = first_animal_to_finish_race(cat_receiver, dog_receiver)\n"
+"        .await\n"
+"        .expect(\"Failed to receive winner\");\n"
+"\n"
+"    println!(\"Winner is {winner:?}\");\n"
+"}\n"
+"```"
+
+#: src/async/control-flow/select.md:62
+#, fuzzy
+msgid ""
+"In this example, we have a race between a cat and a dog. "
+"`first_animal_to_finish_race` listens to both channels and will pick "
+"whichever arrives first. Since the dog takes 50ms, it wins against the cat "
+"that take 500ms seconds."
+msgstr ""
+"이 예제에서는 고양이와 개를 경주시켰습니다(동시에 시작시킨 후, 둘 중 먼저 끝"
+"나는 쪽이 이김). `first_animal_to_finish_race`함수는 두 채널 모두에 귀기울이"
+"고(listen하고) 있다가, 메시지가 먼저 도착한 채널을 선택합니다. 개는 50ms만에 "
+"작업을 끝내고 고양이는 500ms가 걸리기 때문에, 개가 이깁니다."
+
+#: src/async/control-flow/select.md:67
+#, fuzzy
+msgid ""
+"You can use `oneshot` channels in this example as the channels are supposed "
+"to receive only one `send`."
+msgstr ""
+"이 예제에서는 `oneshot` 채널을 사용하는 것이 더 좋은 디자인 입니다. 각 채널"
+"이 한 번의 `send`만 수신해야 하는 것이 보장되기 때문입니다."
+
+#: src/async/control-flow/select.md:70
+#, fuzzy
+msgid ""
+"Try adding a deadline to the race, demonstrating selecting different sorts "
+"of futures."
+msgstr ""
+"이 경주에 타임아웃을 추가해서, 서로 다른 종류의 futures들을 동시에 `select`"
+"할 수 있음을 확인해 보세요."
+
+#: src/async/control-flow/select.md:73
+#, fuzzy
+msgid ""
+"Note that `select!` drops unmatched branches, which cancels their futures. "
+"It is easiest to use when every execution of `select!` creates new futures."
+msgstr ""
+"`select!`는 매칭되지 않은 다른 모든 브랜치에 대해 drop을 수행합니다. 따라서 "
+"경쟁에서 진 모든 future들은  취소(cancel) 됩니다. `select!`를 실행할 때마다 "
+"새로운 futures가 만들어지는 경우라면, 이러한 점이 매우 편하게 느껴질 것입니"
+"다. Future가 취소되는 것을 막기 위해 future를 직접 전달하는 대신 `&mut "
+"future`를 전달하는 것도 가능합니다.  하지만 이렇게 하면 문제가 발생할 수 있습"
+"니다 (왜 그런지는 `Pin`설명할 때 자세히 설명하겠습니다)."
+
+#: src/async/control-flow/select.md:76
+msgid ""
+"An alternative is to pass `&mut future` instead of the future itself, but "
+"this can lead to issues, further discussed in the pinning slide."
+msgstr ""
+
+#: src/async/pitfalls.md:1
+msgid "Pitfalls of async/await"
+msgstr "async/await에서 주의해야할 함정"
+
+#: src/async/pitfalls.md:3
+msgid ""
+"Async / await provides convenient and efficient abstraction for concurrent "
+"asynchronous programming. However, the async/await model in Rust also comes "
+"with its share of pitfalls and footguns. We illustrate some of them in this "
+"chapter:"
+msgstr ""
+"Async와 await는 동시 비동기 프로그래밍을 위한 편리하고 효율적인 추상화를 제공"
+"합니다. 하지만 Rust의 async/await 모델에도 문제는 있습니다. 이 장에서 몇 가"
+"지 예를 살펴보겠습니다."
+
+#: src/async/pitfalls.md:5
+#, fuzzy
+msgid "[Blocking the Executor](pitfalls/blocking-executor.md)"
+msgstr "[실행자 차단](pitfalls/blocking-executor.md)"
+
+#: src/async/pitfalls.md:6
+#, fuzzy
+msgid "[Pin](pitfalls/pin.md)"
+msgstr "[고정](pitfalls/pin.md)"
+
+#: src/async/pitfalls.md:7
+#, fuzzy
+msgid "[Async Traits](pitfalls/async-traits.md)"
+msgstr "[비동기 트레잇](pitfall/async-traits.md)"
+
+#: src/async/pitfalls.md:8
+msgid "[Cancellation](pitfalls/cancellation.md)"
+msgstr ""
+
+#: src/async/pitfalls/blocking-executor.md:1
+msgid "Blocking the executor"
+msgstr "실행자(executor)를 블록시킴"
+
+#: src/async/pitfalls/blocking-executor.md:3
+msgid ""
+"Most async runtimes only allow IO tasks to run concurrently. This means that "
+"CPU blocking tasks will block the executor and prevent other tasks from "
+"being executed. An easy workaround is to use async equivalent methods where "
+"possible."
+msgstr ""
+"대부분의 비동기 런타임은 IO 작업만 동시에 실행되도록 허용합니다. 즉, CPU를 블"
+"럭하는 태스크가 있는 경우, 이는 실행자(executor)를 블럭하게 되며, 그 결과로 "
+"다른 태스크가 실행되지 않습니다. 이 문제를 해결하는 간단한 방법은, 항상 async"
+"를 지원하는 메서드를 사용하는 것입니다."
+
+#: src/async/pitfalls/blocking-executor.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"use futures::future::join_all;\n"
+"use std::time::Instant;\n"
+"\n"
+"async fn sleep_ms(start: &Instant, id: u64, duration_ms: u64) {\n"
+"    std::thread::sleep(std::time::Duration::from_millis(duration_ms));\n"
+"    println!(\n"
+"        \"future {id} slept for {duration_ms}ms, finished after {}ms\",\n"
+"        start.elapsed().as_millis()\n"
+"    );\n"
+"}\n"
+"\n"
+"#[tokio::main(flavor = \"current_thread\")]\n"
+"async fn main() {\n"
+"    let start = Instant::now();\n"
+"    let sleep_futures = (1..=10).map(|t| sleep_ms(&start, t, t * 10));\n"
+"    join_all(sleep_futures).await;\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use futures::future::join_all;\n"
+"use std::time::Instant;\n"
+"\n"
+"async fn sleep_ms(start: &Instant, id: u64, duration_ms: u64) {\n"
+"    std::thread::sleep(std::time::Duration::from_millis(duration_ms));\n"
+"    println!(\n"
+"        \"future {id} slept for {duration_ms}ms, finished after {}ms\",\n"
+"        start.elapsed().as_millis()\n"
+"    );\n"
+"}\n"
+"\n"
+"#[tokio::main(flavor = \"current_thread\")]\n"
+"async fn main() {\n"
+"    let start = Instant::now();\n"
+"    let sleep_futures = (1..=10).map(|t| sleep_ms(&start, t, t * 10));\n"
+"    join_all(sleep_futures).await;\n"
+"}\n"
+"```"
+
+#: src/async/pitfalls/blocking-executor.md:29
+msgid ""
+"Run the code and see that the sleeps happen consecutively rather than "
+"concurrently."
+msgstr ""
+"코드를 실행하여 sleep들이 동시에 진행되지 않고 순차적으로으로 진행되는지 확인"
+"하세요."
+
+#: src/async/pitfalls/blocking-executor.md:32
+msgid ""
+"The `\"current_thread\"` flavor puts all tasks on a single thread. This "
+"makes the effect more obvious, but the bug is still present in the multi-"
+"threaded flavor."
+msgstr ""
+"`flavor`를 `\"current_thread\"` 로 설정하면 모든 태스크가 하나의 스레드에서 "
+"수행됩니다. 이렇게 하면 문제 상황이 더 분명히 드러납니다. 그러나 이 버그는 멀"
+"티스레드인 경우에도 여전히 존재합니다."
+
+#: src/async/pitfalls/blocking-executor.md:36
+msgid ""
+"Switch the `std::thread::sleep` to `tokio::time::sleep` and await its result."
+msgstr ""
+"`std::thread::sleep`을 `tokio::time::sleep`으로 바꾸고 그 결과를 `await`해 보"
+"세요."
+
+#: src/async/pitfalls/blocking-executor.md:38
+msgid ""
+"Another fix would be to `tokio::task::spawn_blocking` which spawns an actual "
+"thread and transforms its handle into a future without blocking the executor."
+msgstr ""
+"또 다른 해결 방법은 `tokio::task::spawn_blocking`입니다. 이는 실제 스레드를 "
+"생성하고, 그 스레드에 대한 핸들을 future로 변환함으로써 실행자가 블록되는 것"
+"을 막습니다."
+
+#: src/async/pitfalls/blocking-executor.md:41
+msgid ""
+"You should not think of tasks as OS threads. They do not map 1 to 1 and most "
+"executors will allow many tasks to run on a single OS thread. This is "
+"particularly problematic when interacting with other libraries via FFI, "
+"where that library might depend on thread-local storage or map to specific "
+"OS threads (e.g., CUDA). Prefer `tokio::task::spawn_blocking` in such "
+"situations."
+msgstr ""
+"태스크를 OS 스레드라고 생각하면 안 됩니다. 태스크와 OS스레드는 일대일 매핑 관"
+"계에 있지 않습니다. 대부분의 실행자는 하나의 OS 스레드에서 최대한 많은 태스크"
+"를 수행하도록 설계되어 있습니다. 이점은 FFI를 통해 다른 라이브러리와 상호작용"
+"할 때 특히 문제가 됩니다. 예를 들어, 해당 라이브러리가 스레드 로컬 저장소를 "
+"이용하거나 특정 OS 스레드에 매핑될 수 있습니다(예: CUDA). 이러한 상황에서는 "
+"`tokio::task::spawn_blocking`을 사용하는 것이 좋습니다."
+
+#: src/async/pitfalls/blocking-executor.md:47
+msgid ""
+"Use sync mutexes with care. Holding a mutex over an `.await` may cause "
+"another task to block, and that task may be running on the same thread."
+msgstr ""
+"동기화 뮤텍스를 주의해서 사용하세요. `.await` 위에 뮤텍스를 적용하면 다른 작"
+"업이 차단될 수 있으며 해당 작업은 동일한 스레드에서 실행 중일 수 있습니다."
+
+#: src/async/pitfalls/pin.md:3
+msgid ""
+"When you await a future, all local variables (that would ordinarily be "
+"stored on a stack frame) are instead stored in the Future for the current "
+"async block. If your future has pointers to data on the stack, those "
+"pointers might get invalidated. This is unsafe."
+msgstr ""
+"Future에 대해 `await`를 호출하여 그 future가 준비되기를 기다릴 때, 모든 로컬 "
+"변수(일반적으로 스택 프레임에 저장됨)는 그 future객체 안에 저장됩니다.  만약 "
+"그 future에 스택에 있는 어떤 데이터로의 포인터가 있으면 이러한 포인터는 올바"
+"르지 않을 수 있습니다. 안전하지 않습니다."
+
+#: src/async/pitfalls/pin.md:8
+msgid ""
+"Therefore, you must guarantee that the addresses your future points to don't "
+"change. That is why we need to `pin` futures. Using the same future "
+"repeatedly in a `select!` often leads to issues with pinned values."
+msgstr ""
+"따라서 future가 가리키는 주소가 변경되지 않도록 해야 합니다. 이것이 future를 "
+"`pin`(고정)해야 하는 이유입니다. `select!`에서 동일한 future를 반복적으로 사"
+"용하면 고정 값 문제가 발생하는 경우가 많습니다."
+
+#: src/async/pitfalls/pin.md:12
+msgid ""
+"```rust,editable,compile_fail\n"
+"use tokio::sync::{mpsc, oneshot};\n"
+"use tokio::task::spawn;\n"
+"use tokio::time::{sleep, Duration};\n"
+"\n"
+"// A work item. In this case, just sleep for the given time and respond\n"
+"// with a message on the `respond_on` channel.\n"
+"#[derive(Debug)]\n"
+"struct Work {\n"
+"    input: u32,\n"
+"    respond_on: oneshot::Sender<u32>,\n"
+"}\n"
+"\n"
+"// A worker which listens for work on a queue and performs it.\n"
+"async fn worker(mut work_queue: mpsc::Receiver<Work>) {\n"
+"    let mut iterations = 0;\n"
+"    loop {\n"
+"        tokio::select! {\n"
+"            Some(work) = work_queue.recv() => {\n"
+"                sleep(Duration::from_millis(10)).await; // Pretend to work.\n"
+"                work.respond_on\n"
+"                    .send(work.input * 1000)\n"
+"                    .expect(\"failed to send response\");\n"
+"                iterations += 1;\n"
+"            }\n"
+"            // TODO: report number of iterations every 100ms\n"
+"        }\n"
+"    }\n"
+"}\n"
+"\n"
+"// A requester which requests work and waits for it to complete.\n"
+"async fn do_work(work_queue: &mpsc::Sender<Work>, input: u32) -> u32 {\n"
+"    let (tx, rx) = oneshot::channel();\n"
+"    work_queue\n"
+"        .send(Work {\n"
+"            input,\n"
+"            respond_on: tx,\n"
+"        })\n"
+"        .await\n"
+"        .expect(\"failed to send on work queue\");\n"
+"    rx.await.expect(\"failed waiting for response\")\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let (tx, rx) = mpsc::channel(10);\n"
+"    spawn(worker(rx));\n"
+"    for i in 0..100 {\n"
+"        let resp = do_work(&tx, i).await;\n"
+"        println!(\"work result for iteration {i}: {resp}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use tokio::sync::{mpsc, oneshot};\n"
+"use tokio::task::spawn;\n"
+"use tokio::time::{sleep, Duration};\n"
+"\n"
+"// 작업 항목. 이 경우 지정된 시간 동안 절전 모드로 있다가\n"
+"// `respond_on` 채널의 메시지로 응답합니다.\n"
+"#[derive(Debug)]\n"
+"struct Work {\n"
+"    input: u32,\n"
+"    respond_on: oneshot::Sender<u32>,\n"
+"}\n"
+"\n"
+"// 대기열에서 작업을 리슨하고 실행하는 worker입니다.\n"
+"async fn worker(mut work_queue: mpsc::Receiver<Work>) {\n"
+"    let mut iterations = 0;\n"
+"    loop {\n"
+"        tokio::select! {\n"
+"            Some(work) = work_queue.recv() => {\n"
+"                sleep(Duration::from_millis(10)).await; // Pretend to work.\n"
+"                work.respond_on\n"
+"                    .send(work.input * 1000)\n"
+"                    .expect(\"failed to send response\");\n"
+"                iterations += 1;\n"
+"            }\n"
+"            // TODO: 100ms마다 반복 횟수를 보고합니다.\n"
+"        }\n"
+"    }\n"
+"}\n"
+"\n"
+"// 작업을 요청하고 작업이 완료될 때까지 기다리는 요청자입니다.\n"
+"async fn do_work(work_queue: &mpsc::Sender<Work>, input: u32) -> u32 {\n"
+"    let (tx, rx) = oneshot::channel();\n"
+"    work_queue\n"
+"        .send(Work {\n"
+"            input,\n"
+"            respond_on: tx,\n"
+"        })\n"
+"        .await\n"
+"        .expect(\"failed to send on work queue\");\n"
+"    rx.await.expect(\"failed waiting for response\")\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let (tx, rx) = mpsc::channel(10);\n"
+"    spawn(worker(rx));\n"
+"    for i in 0..100 {\n"
+"        let resp = do_work(&tx, i).await;\n"
+"        println!(\"work result for iteration {i}: {resp}\");\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/async/pitfalls/pin.md:68
+msgid ""
+"You may recognize this as an example of the actor pattern. Actors typically "
+"call `select!` in a loop."
+msgstr ""
+"위에서 소개한 것은 액터(actor) 패턴의 한 예라고 봐도 무방합니다. 액터는 일반"
+"적으로 루프 안에서 `select!`를 호출합니다."
+
+#: src/async/pitfalls/pin.md:71
+msgid ""
+"This serves as a summation of a few of the previous lessons, so take your "
+"time with it."
+msgstr "이전 강의 몇 개의 내용을 요약한 것이기 때문에 천천히 살펴보세요."
+
+#: src/async/pitfalls/pin.md:74
+msgid ""
+"Naively add a `_ = sleep(Duration::from_millis(100)) => { println!(..) }` to "
+"the `select!`. This will never execute. Why?"
+msgstr ""
+"`_ = sleep(Duration::from_millis(100)) => { println!(..) }`을 `select!`에 추"
+"가해 보세요. 이 작업은 실행되지 않습니다. 왜 그럴까요?"
+
+#: src/async/pitfalls/pin.md:77
+msgid ""
+"Instead, add a `timeout_fut` containing that future outside of the `loop`:"
+msgstr ""
+"대신, 해당 future가 포함된 `timeout_fut`를 `loop` 외부에 추가해 보세요."
+
+#: src/async/pitfalls/pin.md:79
+msgid ""
+"```rust,compile_fail\n"
+"let mut timeout_fut = sleep(Duration::from_millis(100));\n"
+"loop {\n"
+"    select! {\n"
+"        ..,\n"
+"        _ = timeout_fut => { println!(..); },\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,compile_fail\n"
+"let mut timeout_fut = sleep(Duration::from_millis(100));\n"
+"loop {\n"
+"    select! {\n"
+"        ..,\n"
+"        _ = timeout_fut => { println!(..); },\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/async/pitfalls/pin.md:88
+msgid ""
+"This still doesn't work. Follow the compiler errors, adding `&mut` to the "
+"`timeout_fut` in the `select!` to work around the move, then using `Box::"
+"pin`:"
+msgstr ""
+"여전히 작동하지 않습니다. 컴파일러 오류를 따라 `select!`의 `timeout_fut`에 "
+"`&mut`를 추가하여 Move 시멘틱 관련한 문제를 해결하고 `Box::pin`을 사용하세요."
+
+#: src/async/pitfalls/pin.md:92
+msgid ""
+"```rust,compile_fail\n"
+"let mut timeout_fut = Box::pin(sleep(Duration::from_millis(100)));\n"
+"loop {\n"
+"    select! {\n"
+"        ..,\n"
+"        _ = &mut timeout_fut => { println!(..); },\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,compile_fail\n"
+"let mut timeout_fut = Box::pin(sleep(Duration::from_millis(100)));\n"
+"loop {\n"
+"    select! {\n"
+"        ..,\n"
+"        _ = &mut timeout_fut => { println!(..); },\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/async/pitfalls/pin.md:102
+msgid ""
+"This compiles, but once the timeout expires it is `Poll::Ready` on every "
+"iteration (a fused future would help with this). Update to reset "
+"`timeout_fut` every time it expires."
+msgstr ""
+"이는 컴파일은 되지만 타임 아웃이 되면 매번 반복할 때 마다 `Poll::Ready`가 됩"
+"니다(융합된 future가 도움이 될 수 있음). 타임 아웃 될 때마다 `timeout_fut`를 "
+"리셋하도록 수정하세요."
+
+#: src/async/pitfalls/pin.md:106
+msgid ""
+"Box allocates on the heap. In some cases, `std::pin::pin!` (only recently "
+"stabilized, with older code often using `tokio::pin!`) is also an option, "
+"but that is difficult to use for a future that is reassigned."
+msgstr ""
+"Box는 힙에 할당합니다. 경우에 따라 `std::pin::pin!`(최근에야 안정화되었으며 "
+"이전 코드는 `tokio::pin!`을 사용하는 경우가 많음)도 사용할 수 있지만 이는 재"
+"할당된 future에 사용하기가 어렵습니다."
+
+#: src/async/pitfalls/pin.md:110
+msgid ""
+"Another alternative is to not use `pin` at all but spawn another task that "
+"will send to a `oneshot` channel every 100ms."
+msgstr ""
+"또 다른 방법은 `pin`을 아예 사용하지 않고 100ms마다 `oneshot` 채널에 전송할 "
+"다른 작업을 생성하는 것입니다."
+
+#: src/async/pitfalls/async-traits.md:3
+msgid ""
+"Async methods in traits are not yet supported in the stable channel ([An "
+"experimental feature exists in nightly and should be stabilized in the mid "
+"term.](https://blog.rust-lang.org/inside-rust/2022/11/17/async-fn-in-trait-"
+"nightly.html))"
+msgstr ""
+"트레잇에 async 메소드를 추가하는 것은 아직 안정화 버전 채널에서 지원되지 않습"
+"니다([실험용 기능은 nightly에 존재하며 조만간 안정화 될 것입니다](https://"
+"blog.rust-lang.org/inside-rust/2022/11/17/async-fn-in-trait-nightly.html))."
+
+#: src/async/pitfalls/async-traits.md:5
+msgid ""
+"The crate [async_trait](https://docs.rs/async-trait/latest/async_trait/) "
+"provides a workaround through a macro:"
+msgstr ""
+"크레이트 [async_trait](https://docs.rs/async-trait/latest/async_trait/)은 매"
+"크로를 통한 해결 방법을 제공합니다."
+
+#: src/async/pitfalls/async-traits.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"use async_trait::async_trait;\n"
+"use std::time::Instant;\n"
+"use tokio::time::{sleep, Duration};\n"
+"\n"
+"#[async_trait]\n"
+"trait Sleeper {\n"
+"    async fn sleep(&self);\n"
+"}\n"
+"\n"
+"struct FixedSleeper {\n"
+"    sleep_ms: u64,\n"
+"}\n"
+"\n"
+"#[async_trait]\n"
+"impl Sleeper for FixedSleeper {\n"
+"    async fn sleep(&self) {\n"
+"        sleep(Duration::from_millis(self.sleep_ms)).await;\n"
+"    }\n"
+"}\n"
+"\n"
+"async fn run_all_sleepers_multiple_times(sleepers: Vec<Box<dyn Sleeper>>, "
+"n_times: usize) {\n"
+"    for _ in 0..n_times {\n"
+"        println!(\"running all sleepers..\");\n"
+"        for sleeper in &sleepers {\n"
+"            let start = Instant::now();\n"
+"            sleeper.sleep().await;\n"
+"            println!(\"slept for {}ms\", start.elapsed().as_millis());\n"
+"        }\n"
+"    }\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let sleepers: Vec<Box<dyn Sleeper>> = vec![\n"
+"        Box::new(FixedSleeper { sleep_ms: 50 }),\n"
+"        Box::new(FixedSleeper { sleep_ms: 100 }),\n"
+"    ];\n"
+"    run_all_sleepers_multiple_times(sleepers, 5).await;\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable,compile_fail\n"
+"use async_trait::async_trait;\n"
+"use std::time::Instant;\n"
+"use tokio::time::{sleep, Duration};\n"
+"\n"
+"#[async_trait]\n"
+"trait Sleeper {\n"
+"    async fn sleep(&self);\n"
+"}\n"
+"\n"
+"struct FixedSleeper {\n"
+"    sleep_ms: u64,\n"
+"}\n"
+"\n"
+"#[async_trait]\n"
+"impl Sleeper for FixedSleeper {\n"
+"    async fn sleep(&self) {\n"
+"        sleep(Duration::from_millis(self.sleep_ms)).await;\n"
+"    }\n"
+"}\n"
+"\n"
+"async fn run_all_sleepers_multiple_times(sleepers: Vec<Box<dyn Sleeper>>, "
+"n_times: usize) {\n"
+"    for _ in 0..n_times {\n"
+"        println!(\"running all sleepers..\");\n"
+"        for sleeper in &sleepers {\n"
+"            let start = Instant::now();\n"
+"            sleeper.sleep().await;\n"
+"            println!(\"slept for {}ms\", start.elapsed().as_millis());\n"
+"        }\n"
+"    }\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    let sleepers: Vec<Box<dyn Sleeper>> = vec![\n"
+"        Box::new(FixedSleeper { sleep_ms: 50 }),\n"
+"        Box::new(FixedSleeper { sleep_ms: 100 }),\n"
+"    ];\n"
+"    run_all_sleepers_multiple_times(sleepers, 5).await;\n"
+"}\n"
+"```"
+
+#: src/async/pitfalls/async-traits.md:51
+msgid ""
+"`async_trait` is easy to use, but note that it's using heap allocations to "
+"achieve this. This heap allocation has performance overhead."
+msgstr ""
+"`async_trait`은 사용하기 쉽지만 이를 위해 힙에 메모리를  할당한다는 점에 유의"
+"하세요. 이 힙 할당에는 성능 오버헤드가 있습니다."
+
+#: src/async/pitfalls/async-traits.md:54
+msgid ""
+"The challenges in language support for `async trait` are deep Rust and "
+"probably not worth describing in-depth. Niko Matsakis did a good job of "
+"explaining them in [this post](https://smallcultfollowing.com/babysteps/"
+"blog/2019/10/26/async-fn-in-traits-are-hard/) if you are interested in "
+"digging deeper."
+msgstr ""
+"`async trait` 를 언어 차원에서 지원하는 것과 관련된 문제는 매우 전문적인 토픽"
+"이며 따라서 이 강의에서 다룰 내용은 아닙니다. [이 게시물](https://"
+"smallcultfollowing.com/babysteps/blog/2019/10/26/async-fn-in-traits-are-"
+"hard/)에 이에 관한 니코 마사키스의 좋은 설명이 있으므로 관심이 있다면 참고하"
+"세요."
+
+#: src/async/pitfalls/async-traits.md:60
+msgid ""
+"Try creating a new sleeper struct that will sleep for a random amount of "
+"time and adding it to the Vec."
+msgstr ""
+"임의의 시간 동안 sleep 하는 새로운 sleeper 구조체를 만들어 Vec에 추가해 보세"
+"요."
+
+#: src/async/pitfalls/cancellation.md:3
+msgid ""
+"Dropping a future implies it can never be polled again. This is called "
+"_cancellation_ and it can occur at any `await` point. Care is needed to "
+"ensure the system works correctly even when futures are cancelled. For "
+"example, it shouldn't deadlock or lose data."
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:8
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::io::{self, ErrorKind};\n"
+"use std::time::Duration;\n"
+"use tokio::io::{AsyncReadExt, AsyncWriteExt, DuplexStream};\n"
+"\n"
+"struct LinesReader {\n"
+"    stream: DuplexStream,\n"
+"}\n"
+"\n"
+"impl LinesReader {\n"
+"    fn new(stream: DuplexStream) -> Self {\n"
+"        Self { stream }\n"
+"    }\n"
+"\n"
+"    async fn next(&mut self) -> io::Result<Option<String>> {\n"
+"        let mut bytes = Vec::new();\n"
+"        let mut buf = [0];\n"
+"        while self.stream.read(&mut buf[..]).await? != 0 {\n"
+"            bytes.push(buf[0]);\n"
+"            if buf[0] == b'\\n' {\n"
+"                break;\n"
+"            }\n"
+"        }\n"
+"        if bytes.is_empty() {\n"
+"            return Ok(None)\n"
+"        }\n"
+"        let s = String::from_utf8(bytes)\n"
+"            .map_err(|_| io::Error::new(ErrorKind::InvalidData, \"not "
+"UTF-8\"))?;\n"
+"        Ok(Some(s))\n"
+"    }\n"
+"}\n"
+"\n"
+"async fn slow_copy(source: String, mut dest: DuplexStream) -> std::io::"
+"Result<()> {\n"
+"    for b in source.bytes() {\n"
+"        dest.write_u8(b).await?;\n"
+"        tokio::time::sleep(Duration::from_millis(10)).await\n"
+"    }\n"
+"    Ok(())\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> std::io::Result<()> {\n"
+"    let (client, server) = tokio::io::duplex(5);\n"
+"    let handle = tokio::spawn(slow_copy(\"hi\\nthere\\n\".to_owned(), "
+"client));\n"
+"\n"
+"    let mut lines = LinesReader::new(server);\n"
+"    let mut interval = tokio::time::interval(Duration::from_millis(60));\n"
+"    loop {\n"
+"        tokio::select! {\n"
+"            _ = interval.tick() => println!(\"tick!\"),\n"
+"            line = lines.next() => if let Some(l) = line? {\n"
+"                print!(\"{}\", l)\n"
+"            } else {\n"
+"                break\n"
+"            },\n"
+"        }\n"
+"    }\n"
+"    handle.await.unwrap()?;\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:72
+msgid ""
+"The compiler doesn't help with cancellation-safety. You need to read API "
+"documentation and consider what state your `async fn` holds."
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:75
+msgid ""
+"Unlike `panic` and `?`, cancellation is part of normal control flow (vs "
+"error-handling)."
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:78
+msgid "The example loses parts of the string."
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:80
+msgid ""
+"Whenever the `tick()` branch finishes first, `next()` and its `buf` are "
+"dropped."
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:82
+msgid ""
+"`LinesReader` can be made cancellation-safe by makeing `buf` part of the "
+"struct:"
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:83
+msgid ""
+"```rust,compile_fail\n"
+"struct LinesReader {\n"
+"    stream: DuplexStream,\n"
+"    bytes: Vec<u8>,\n"
+"    buf: [u8; 1],\n"
+"}\n"
+"\n"
+"impl LinesReader {\n"
+"    fn new(stream: DuplexStream) -> Self {\n"
+"        Self { stream, bytes: Vec::new(), buf: [0] }\n"
+"    }\n"
+"    async fn next(&mut self) -> io::Result<Option<String>> {\n"
+"        // prefix buf and bytes with self.\n"
+"        // ...\n"
+"        let raw = std::mem::take(&mut self.bytes);\n"
+"        let s = String::from_utf8(raw)\n"
+"        // ...\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:104
+msgid ""
+"[`Interval::tick`](https://docs.rs/tokio/latest/tokio/time/struct.Interval."
+"html#method.tick) is cancellation-safe because it keeps track of whether a "
+"tick has been 'delivered'."
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:107
+msgid ""
+"[`AsyncReadExt::read`](https://docs.rs/tokio/latest/tokio/io/trait."
+"AsyncReadExt.html#method.read) is cancellation-safe because it either "
+"returns or doesn't read data."
+msgstr ""
+
+#: src/async/pitfalls/cancellation.md:110
+msgid ""
+"[`AsyncBufReadExt::read_line`](https://docs.rs/tokio/latest/tokio/io/trait."
+"AsyncBufReadExt.html#method.read_line) is similar to the example and _isn't_ "
+"cancellation-safe. See its documentation for details and alternatives."
+msgstr ""
+
+#: src/exercises/concurrency/afternoon.md:3
+msgid ""
+"To practice your Async Rust skills, we have again two exercises for you:"
+msgstr ""
+
+#: src/exercises/concurrency/afternoon.md:5
+msgid ""
+"Dining philosophers: we already saw this problem in the morning. This time "
+"you are going to implement it with Async Rust."
+msgstr ""
+
+#: src/exercises/concurrency/afternoon.md:8
+msgid ""
+"A Broadcast Chat Application: this is a larger project that allows you "
+"experiment with more advanced Async Rust features."
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:1
+#: src/exercises/concurrency/solutions-afternoon.md:3
+#, fuzzy
+msgid "Dining Philosophers - Async"
+msgstr "식사하는 철학자들"
+
+#: src/exercises/concurrency/dining-philosophers-async.md:3
+msgid ""
+"See [dining philosophers](dining-philosophers.md) for a description of the "
+"problem."
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:6
+#, fuzzy
+msgid ""
+"As before, you will need a local [Cargo installation](../../cargo/running-"
+"locally.md) for this exercise. Copy the code below to a file called `src/"
+"main.rs`, fill out the blanks, and test that `cargo run` does not deadlock:"
+msgstr ""
+"이번 훈련에서는 [카고 설치하기](../../cargo/running-locally.md)가 필요합니"
+"다. 아래 코드를 복사해서 `src/main.rs`에 붙여놓고 빈 부분을 채우고, `cargo "
+"run` 커맨드로 테스트 해서 교착상태(데드락)가 발생하지 않는지 확인합니다:"
+
+#: src/exercises/concurrency/dining-philosophers-async.md:13
+msgid ""
+"```rust,compile_fail\n"
+"use std::sync::Arc;\n"
+"use tokio::time;\n"
+"use tokio::sync::mpsc::{self, Sender};\n"
+"use tokio::sync::Mutex;\n"
+"\n"
+"struct Fork;\n"
+"\n"
+"struct Philosopher {\n"
+"    name: String,\n"
+"    // left_fork: ...\n"
+"    // right_fork: ...\n"
+"    // thoughts: ...\n"
+"}\n"
+"\n"
+"impl Philosopher {\n"
+"    async fn think(&self) {\n"
+"        self.thoughts\n"
+"            .send(format!(\"Eureka! {} has a new idea!\", &self.name))."
+"await\n"
+"            .unwrap();\n"
+"    }\n"
+"\n"
+"    async fn eat(&self) {\n"
+"        // Pick up forks...\n"
+"        println!(\"{} is eating...\", &self.name);\n"
+"        time::sleep(time::Duration::from_millis(5)).await;\n"
+"    }\n"
+"}\n"
+"\n"
+"static PHILOSOPHERS: &[&str] =\n"
+"    &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    // Create forks\n"
+"\n"
+"    // Create philosophers\n"
+"\n"
+"    // Make them think and eat\n"
+"\n"
+"    // Output their thoughts\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:57
+msgid ""
+"Since this time you are using Async Rust, you'll need a `tokio` dependency. "
+"You can use the following `Cargo.toml`:"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:62
+msgid ""
+"```toml\n"
+"[package]\n"
+"name = \"dining-philosophers-async-dine\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"\n"
+"[dependencies]\n"
+"tokio = {version = \"1.26.0\", features = [\"sync\", \"time\", \"macros\", "
+"\"rt-multi-thread\"]}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:72
+msgid ""
+"Also note that this time you have to use the `Mutex` and the `mpsc` module "
+"from the `tokio` crate."
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:77
+msgid "Can you make your implementation single-threaded? "
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:3
+msgid ""
+"In this exercise, we want to use our new knowledge to implement a broadcast "
+"chat application. We have a chat server that the clients connect to and "
+"publish their messages. The client reads user messages from the standard "
+"input, and sends them to the server. The chat server broadcasts each message "
+"that it receives to all the clients."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:9
+msgid ""
+"For this, we use [a broadcast channel](https://docs.rs/tokio/latest/tokio/"
+"sync/broadcast/fn.channel.html) on the server, and [`tokio_websockets`]"
+"(https://docs.rs/tokio-websockets/0.3.2/tokio_websockets/) for the "
+"communication between the client and the server."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:13
+msgid "Create a new Cargo project and add the following dependencies:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:15
+msgid "`Cargo.toml`:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:19
+msgid ""
+"```toml\n"
+"[package]\n"
+"name = \"chat-async\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"\n"
+"[dependencies]\n"
+"futures-util = \"0.3.28\"\n"
+"http = \"0.2.9\"\n"
+"tokio = { version = \"1.28.1\", features = [\"full\"] }\n"
+"tokio-websockets = \"0.3.2\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:32
+msgid "The required APIs"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:33
+msgid ""
+"You are going to need the following functions from `tokio` and "
+"[`tokio_websockets`](https://docs.rs/tokio-websockets/0.3.2/"
+"tokio_websockets/). Spend a few minutes to familiarize yourself with the "
+"API. "
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:37
+msgid ""
+"[WebsocketStream::next()](https://docs.rs/tokio-websockets/0.3.2/"
+"tokio_websockets/proto/struct.WebsocketStream.html#method.next): for "
+"asynchronously reading messages from a Websocket Stream."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:39
+msgid ""
+"[SinkExt::send()](https://docs.rs/futures-util/0.3.28/futures_util/sink/"
+"trait.SinkExt.html#method.send) implemented by `WebsocketStream`: for "
+"asynchronously sending messages on a Websocket Stream."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:41
+msgid ""
+"[Lines::next_line()](https://docs.rs/tokio/latest/tokio/io/struct.Lines."
+"html#method.next_line): for asynchronously reading user messages from the "
+"standard input."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:43
+msgid ""
+"[Sender::subscribe()](https://docs.rs/tokio/latest/tokio/sync/broadcast/"
+"struct.Sender.html#method.subscribe): for subscribing to a broadcast channel."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:46
+#, fuzzy
+msgid "Two binaries"
+msgstr "러스트 바이너리"
+
+#: src/exercises/concurrency/chat-app.md:48
+msgid ""
+"Normally in a Cargo project, you can have only one binary, and one `src/main."
+"rs` file. In this project, we need two binaries. One for the client, and one "
+"for the server. You could potentially make them two separate Cargo projects, "
+"but we are going to put them in a single Cargo project with two binaries. "
+"For this to work, the client and the server code should go under `src/bin` "
+"(see the [documentation](https://doc.rust-lang.org/cargo/reference/cargo-"
+"targets.html#binaries)). "
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:55
+msgid ""
+"Copy the following server and client code into `src/bin/server.rs` and `src/"
+"bin/client.rs`, respectively. Your task is to complete these files as "
+"described below. "
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:59
+#: src/exercises/concurrency/solutions-afternoon.md:123
+msgid "`src/bin/server.rs`:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:63
+msgid ""
+"```rust,compile_fail\n"
+"use futures_util::sink::SinkExt;\n"
+"use std::error::Error;\n"
+"use std::net::SocketAddr;\n"
+"use tokio::net::{TcpListener, TcpStream};\n"
+"use tokio::sync::broadcast::{channel, Sender};\n"
+"use tokio_websockets::{Message, ServerBuilder, WebsocketStream};\n"
+"\n"
+"async fn handle_connection(\n"
+"    addr: SocketAddr,\n"
+"    mut ws_stream: WebsocketStream<TcpStream>,\n"
+"    bcast_tx: Sender<String>,\n"
+") -> Result<(), Box<dyn Error + Send + Sync>> {\n"
+"\n"
+"    // TODO: For a hint, see the description of the task below.\n"
+"\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {\n"
+"    let (bcast_tx, _) = channel(16);\n"
+"\n"
+"    let listener = TcpListener::bind(\"127.0.0.1:2000\").await?;\n"
+"    println!(\"listening on port 2000\");\n"
+"\n"
+"    loop {\n"
+"        let (socket, addr) = listener.accept().await?;\n"
+"        println!(\"New connection from {addr:?}\");\n"
+"        let bcast_tx = bcast_tx.clone();\n"
+"        tokio::spawn(async move {\n"
+"            // Wrap the raw TCP stream into a websocket.\n"
+"            let ws_stream = ServerBuilder::new().accept(socket).await?;\n"
+"\n"
+"            handle_connection(addr, ws_stream, bcast_tx).await\n"
+"        });\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:102
+#: src/exercises/concurrency/solutions-afternoon.md:208
+msgid "`src/bin/client.rs`:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:106
+msgid ""
+"```rust,compile_fail\n"
+"use futures_util::SinkExt;\n"
+"use http::Uri;\n"
+"use tokio::io::{AsyncBufReadExt, BufReader};\n"
+"use tokio_websockets::{ClientBuilder, Message};\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> Result<(), tokio_websockets::Error> {\n"
+"    let mut ws_stream = ClientBuilder::from_uri(Uri::"
+"from_static(\"ws://127.0.0.1:2000\"))\n"
+"        .connect()\n"
+"        .await?;\n"
+"\n"
+"    let stdin = tokio::io::stdin();\n"
+"    let mut stdin = BufReader::new(stdin).lines();\n"
+"\n"
+"\n"
+"    // TODO: For a hint, see the description of the task below.\n"
+"\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:127
+#, fuzzy
+msgid "Running the binaries"
+msgstr "강의 진행 방식"
+
+#: src/exercises/concurrency/chat-app.md:128
+#, fuzzy
+msgid "Run the server with:"
+msgstr "아래 명령어로 예제 코드를 실행하세요."
+
+#: src/exercises/concurrency/chat-app.md:130
+#, fuzzy
+msgid ""
+"```shell\n"
+"cargo run --bin server\n"
+"```"
+msgstr ""
+"```sh\n"
+"cargo embed --bin pac\n"
+"```"
+
+#: src/exercises/concurrency/chat-app.md:134
+#, fuzzy
+msgid "and the client with:"
+msgstr "아래 명령어로 예제 코드를 실행하세요."
+
+#: src/exercises/concurrency/chat-app.md:136
+#, fuzzy
+msgid ""
+"```shell\n"
+"cargo run --bin client\n"
+"```"
+msgstr ""
+"```sh\n"
+"cargo embed --bin pac\n"
+"```"
+
+#: src/exercises/concurrency/chat-app.md:142
+msgid "Implement the `handle_connection` function in `src/bin/server.rs`."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:143
+msgid ""
+"Hint: Use `tokio::select!` for concurrently performing two tasks in a "
+"continuous loop. One task receives messages from the client and broadcasts "
+"them. The other sends messages received by the server to the client."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:146
+msgid "Complete the main function in `src/bin/client.rs`."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:147
+msgid ""
+"Hint: As before, use `tokio::select!` in a continuous loop for concurrently "
+"performing two tasks: (1) reading user messages from standard input and "
+"sending them to the server, and (2) receiving messages from the server, and "
+"displaying them for the user."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:151
+msgid ""
+"Optional: Once you are done, change the code to broadcast messages to all "
+"clients, but the sender of the message."
+msgstr ""
+
 #: src/thanks.md:3
 msgid ""
 "_Thank you for taking Comprehensive Rust 🦀!_ We hope you enjoyed it and "
@@ -21084,18 +25404,20 @@ msgstr ""
 "의 전체 목록은 [other resources](other-resources.md)에서 살펴보시기 바랍니다."
 
 #: src/credits.md:7
+#, fuzzy
 msgid ""
 "The material of Comprehensive Rust is licensed under the terms of the Apache "
-"2.0 license, please see [`LICENSE`](../LICENSE) for details."
+"2.0 license, please see [`LICENSE`](https://github.com/google/comprehensive-"
+"rust/blob/main/LICENSE) for details."
 msgstr ""
 "Comprehensive Rust의 자료는 Apache 2.0 라이선스를 따릅니다. 자세한건 "
 "[`LICENSE`](../LICENSE) 확인해 보시기 바랍니다."
 
-#: src/credits.md:10
+#: src/credits.md:12
 msgid "Rust by Example"
 msgstr "Rust by Example"
 
-#: src/credits.md:12
+#: src/credits.md:14
 msgid ""
 "Some examples and exercises have been copied and adapted from [Rust by "
 "Example](https://doc.rust-lang.org/rust-by-example/). Please see the "
@@ -21106,11 +25428,11 @@ msgstr ""
 "example/)을 참조하였습니다. 라이선스 조항을 포함하여 저장소의 `third_party/"
 "rust-by-example/` 폴더를 참조하시기 바랍니다."
 
-#: src/credits.md:17
+#: src/credits.md:19
 msgid "Rust on Exercism"
 msgstr "Rust on Exercism"
 
-#: src/credits.md:19
+#: src/credits.md:21
 msgid ""
 "Some exercises have been copied and adapted from [Rust on Exercism](https://"
 "exercism.org/tracks/rust). Please see the `third_party/rust-on-exercism/` "
@@ -21120,11 +25442,11 @@ msgstr ""
 "였습니다. 라이선스 조항을 포함하여 저장소의 `third_party/rust-on-exercism/`폴"
 "더를 참조하시기 바랍니다."
 
-#: src/credits.md:24
+#: src/credits.md:26
 msgid "CXX"
 msgstr "CXX"
 
-#: src/credits.md:26
+#: src/credits.md:28
 msgid ""
 "The [Interoperability with C++](android/interoperability/cpp.md) section "
 "uses an image from [CXX](https://cxx.rs/). Please see the `third_party/cxx/` "
@@ -21318,6 +25640,10 @@ msgstr ""
 msgid "Day 1 Afternoon Exercises"
 msgstr "1일차 오후 연습문제"
 
+#: src/exercises/day-1/solutions-afternoon.md:3
+msgid "Designing a Library"
+msgstr "도서관 설계"
+
 #: src/exercises/day-1/solutions-afternoon.md:5
 msgid "([back to exercise](book-library.md))"
 msgstr ""
@@ -21359,16 +25685,16 @@ msgid ""
 "    }\n"
 "}\n"
 "\n"
-"// This makes it possible to print Book values with {}.\n"
-"impl std::fmt::Display for Book {\n"
-"    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n"
-"        write!(f, \"{} ({})\", self.title, self.year)\n"
-"    }\n"
-"}\n"
-"// ANCHOR_END: setup\n"
-"\n"
-"// ANCHOR: Library_new\n"
+"// Implement the methods below. Update the `self` parameter to\n"
+"// indicate the method's required level of ownership over the object:\n"
+"//\n"
+"// - `&self` for shared read-only access,\n"
+"// - `&mut self` for unique and mutable access,\n"
+"// - `self` for unique access by value.\n"
 "impl Library {\n"
+"    // ANCHOR_END: setup\n"
+"\n"
+"    // ANCHOR: Library_new\n"
 "    fn new() -> Library {\n"
 "        // ANCHOR_END: Library_new\n"
 "        Library { books: Vec::new() }\n"
@@ -21376,7 +25702,7 @@ msgid ""
 "\n"
 "    // ANCHOR: Library_len\n"
 "    //fn len(self) -> usize {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Return the length of `self.books`\")\n"
 "    //}\n"
 "    // ANCHOR_END: Library_len\n"
 "    fn len(&self) -> usize {\n"
@@ -21385,7 +25711,7 @@ msgid ""
 "\n"
 "    // ANCHOR: Library_is_empty\n"
 "    //fn is_empty(self) -> bool {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Return `true` if `self.books` is empty\")\n"
 "    //}\n"
 "    // ANCHOR_END: Library_is_empty\n"
 "    fn is_empty(&self) -> bool {\n"
@@ -21394,7 +25720,7 @@ msgid ""
 "\n"
 "    // ANCHOR: Library_add_book\n"
 "    //fn add_book(self, book: Book) {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Add a new book to `self.books`\")\n"
 "    //}\n"
 "    // ANCHOR_END: Library_add_book\n"
 "    fn add_book(&mut self, book: Book) {\n"
@@ -21403,22 +25729,34 @@ msgid ""
 "\n"
 "    // ANCHOR: Library_print_books\n"
 "    //fn print_books(self) {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Iterate over `self.books` and each book's title and "
+"year\")\n"
 "    //}\n"
 "    // ANCHOR_END: Library_print_books\n"
 "    fn print_books(&self) {\n"
 "        for book in &self.books {\n"
-"            println!(\"{}\", book);\n"
+"            println!(\"{}, published in {}\", book.title, book.year);\n"
 "        }\n"
 "    }\n"
 "\n"
 "    // ANCHOR: Library_oldest_book\n"
 "    //fn oldest_book(self) -> Option<&Book> {\n"
-"    //    unimplemented!()\n"
+"    //    todo!(\"Return a reference to the oldest book (if any)\")\n"
 "    //}\n"
 "    // ANCHOR_END: Library_oldest_book\n"
 "    fn oldest_book(&self) -> Option<&Book> {\n"
-"        self.books.iter().min_by_key(|book| book.year)\n"
+"        // Using a closure and a built-in method:\n"
+"        // self.books.iter().min_by_key(|book| book.year)\n"
+"\n"
+"        // Longer hand-written solution:\n"
+"        let mut oldest: Option<&Book> = None;\n"
+"        for book in self.books.iter() {\n"
+"            if oldest.is_none() || book.year < oldest.unwrap().year {\n"
+"                oldest = Some(book);\n"
+"            }\n"
+"        }\n"
+"\n"
+"        oldest\n"
 "    }\n"
 "}\n"
 "\n"
@@ -21430,26 +25768,26 @@ msgid ""
 "fn main() {\n"
 "    let library = Library::new();\n"
 "\n"
-"    //println!(\"Our library is empty: {}\", library.is_empty());\n"
-"\n"
-"    let favorite_book = Book::new(\"Lord of the Rings\", 1954);\n"
-"    println!(\"Our favorite book {favorite_book} should go in the "
-"library\");\n"
-"    //library.add_book(favorite_book);\n"
+"    //println!(\"The library is empty: library.is_empty() -> {}\", library."
+"is_empty());\n"
+"    //\n"
+"    //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
 "    //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
 "1865));\n"
 "    //\n"
+"    //println!(\"The library is no longer empty: library.is_empty() -> {}\", "
+"library.is_empty());\n"
+"    //\n"
+"    //\n"
 "    //library.print_books();\n"
 "    //\n"
 "    //match library.oldest_book() {\n"
-"    //    Some(book) => println!(\"My oldest book is {book}\"),\n"
-"    //    None => println!(\"My library is empty!\"),\n"
+"    //    Some(book) => println!(\"The oldest book is {}\", book.title),\n"
+"    //    None => println!(\"The library is empty!\"),\n"
 "    //}\n"
 "    //\n"
-"    //println!(\"Our library has {} books\", library.len());\n"
-"    for book in library.books {\n"
-"        println!(\"{book}\");\n"
-"    }\n"
+"    //println!(\"The library has {} books\", library.len());\n"
+"    //library.print_books();\n"
 "}\n"
 "// ANCHOR_END: main\n"
 "\n"
@@ -21616,6 +25954,17 @@ msgid ""
 "        }\n"
 "        result += last_point.dist(self.points[0]);\n"
 "        result\n"
+"        // Alternatively, Iterator::zip() lets us iterate over the points as "
+"pairs\n"
+"        // but we need to pair each point with the next one, and the last "
+"point\n"
+"        // with the first point. The zip() iterator is finished as soon as "
+"one of \n"
+"        // the source iterators is finished, a neat trick is to combine "
+"Iterator::cycle\n"
+"        // with Iterator::skip to create the second iterator for the zip and "
+"using map \n"
+"        // and sum to calculate the total length.\n"
 "    }\n"
 "}\n"
 "\n"
@@ -21803,8 +26152,7 @@ msgid ""
 "fn main() {\n"
 "    let cc_number = \"1234 5678 1234 5670\";\n"
 "    println!(\n"
-"        \"Is {} a valid credit card number? {}\",\n"
-"        cc_number,\n"
+"        \"Is {cc_number} a valid credit card number? {}\",\n"
 "        if luhn(cc_number) { \"yes\" } else { \"no\" }\n"
 "    );\n"
 "}\n"
@@ -21850,11 +26198,11 @@ msgid ""
 "```"
 msgstr ""
 
-#: src/exercises/day-2/solutions-afternoon.md:100
+#: src/exercises/day-2/solutions-afternoon.md:99
 msgid "([back to exercise](strings-iterators.md))"
 msgstr ""
 
-#: src/exercises/day-2/solutions-afternoon.md:102
+#: src/exercises/day-2/solutions-afternoon.md:101
 msgid ""
 "```rust\n"
 "// Copyright 2022 Google LLC\n"
@@ -21874,23 +26222,30 @@ msgid ""
 "// ANCHOR: prefix_matches\n"
 "pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {\n"
 "    // ANCHOR_END: prefix_matches\n"
-"    let prefixes = prefix.split('/');\n"
-"    let request_paths = request_path\n"
-"        .split('/')\n"
-"        .map(|p| Some(p))\n"
-"        .chain(std::iter::once(None));\n"
 "\n"
-"    for (prefix, request_path) in prefixes.zip(request_paths) {\n"
-"        match request_path {\n"
-"            Some(request_path) => {\n"
-"                if (prefix != \"*\") && (prefix != request_path) {\n"
-"                    return false;\n"
-"                }\n"
-"            }\n"
-"            None => return false,\n"
+"    let mut request_segments = request_path.split('/');\n"
+"\n"
+"    for prefix_segment in prefix.split('/') {\n"
+"        let Some(request_segment) = request_segments.next() else {\n"
+"            return false;\n"
+"        };\n"
+"        if request_segment != prefix_segment && prefix_segment != \"*\" {\n"
+"            return false;\n"
 "        }\n"
 "    }\n"
 "    true\n"
+"\n"
+"    // Alternatively, Iterator::zip() lets us iterate simultaneously over "
+"prefix\n"
+"    // and request segments. The zip() iterator is finished as soon as one "
+"of\n"
+"    // the source iterators is finished, but we need to iterate over all "
+"request\n"
+"    // segments. A neat trick that makes zip() work is to use map() and "
+"chain()\n"
+"    // to produce an iterator that returns Some(str) for each pattern "
+"segments,\n"
+"    // and then returns None indefinitely.\n"
 "}\n"
 "\n"
 "// ANCHOR: unit-tests\n"
@@ -22019,6 +26374,13 @@ msgid ""
 "    fn add_widget(&mut self, widget: Box<dyn Widget>) {\n"
 "        self.widgets.push(widget);\n"
 "    }\n"
+"\n"
+"    fn inner_width(&self) -> usize {\n"
+"        std::cmp::max(\n"
+"            self.title.chars().count(),\n"
+"            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),\n"
+"        )\n"
+"    }\n"
 "}\n"
 "\n"
 "// ANCHOR_END: setup\n"
@@ -22027,10 +26389,8 @@ msgid ""
 "impl Widget for Window {\n"
 "    fn width(&self) -> usize {\n"
 "        // ANCHOR_END: Window-width\n"
-"        std::cmp::max(\n"
-"            self.title.chars().count(),\n"
-"            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),\n"
-"        )\n"
+"        // Add 4 paddings for borders\n"
+"        self.inner_width() + 4\n"
 "    }\n"
 "\n"
 "    // ANCHOR: Window-draw_into\n"
@@ -22041,18 +26401,18 @@ msgid ""
 "            widget.draw_into(&mut inner);\n"
 "        }\n"
 "\n"
-"        let window_width = self.width();\n"
+"        let inner_width = self.inner_width();\n"
 "\n"
 "        // TODO: after learning about error handling, you can change\n"
 "        // draw_into to return Result<(), std::fmt::Error>. Then use\n"
 "        // the ?-operator here instead of .unwrap().\n"
-"        writeln!(buffer, \"+-{:-<window_width$}-+\", \"\").unwrap();\n"
-"        writeln!(buffer, \"| {:^window_width$} |\", &self.title).unwrap();\n"
-"        writeln!(buffer, \"+={:=<window_width$}=+\", \"\").unwrap();\n"
+"        writeln!(buffer, \"+-{:-<inner_width$}-+\", \"\").unwrap();\n"
+"        writeln!(buffer, \"| {:^inner_width$} |\", &self.title).unwrap();\n"
+"        writeln!(buffer, \"+={:=<inner_width$}=+\", \"\").unwrap();\n"
 "        for line in inner.lines() {\n"
-"            writeln!(buffer, \"| {:window_width$} |\", line).unwrap();\n"
+"            writeln!(buffer, \"| {:inner_width$} |\", line).unwrap();\n"
 "        }\n"
-"        writeln!(buffer, \"+-{:-<window_width$}-+\", \"\").unwrap();\n"
+"        writeln!(buffer, \"+-{:-<inner_width$}-+\", \"\").unwrap();\n"
 "    }\n"
 "}\n"
 "\n"
@@ -22138,7 +26498,9 @@ msgid ""
 "\n"
 "// ANCHOR: ffi\n"
 "mod ffi {\n"
-"    use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};\n"
+"    use std::os::raw::{c_char, c_int};\n"
+"    #[cfg(not(target_os = \"macos\"))]\n"
+"    use std::os::raw::{c_long, c_ulong, c_ushort, c_uchar};\n"
 "\n"
 "    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.\n"
 "    #[repr(C)]\n"
@@ -22148,20 +26510,50 @@ msgid ""
 "PhantomPinned)>,\n"
 "    }\n"
 "\n"
-"    // Layout as per readdir(3) and definitions in /usr/include/x86_64-linux-"
-"gnu.\n"
+"    // Layout according to the Linux man page for readdir(3), where ino_t "
+"and\n"
+"    // off_t are resolved according to the definitions in\n"
+"    // /usr/include/x86_64-linux-gnu/{sys/types.h, bits/typesizes.h}.\n"
+"    #[cfg(not(target_os = \"macos\"))]\n"
 "    #[repr(C)]\n"
 "    pub struct dirent {\n"
-"        pub d_ino: c_long,\n"
-"        pub d_off: c_ulong,\n"
+"        pub d_ino: c_ulong,\n"
+"        pub d_off: c_long,\n"
 "        pub d_reclen: c_ushort,\n"
-"        pub d_type: c_char,\n"
+"        pub d_type: c_uchar,\n"
 "        pub d_name: [c_char; 256],\n"
 "    }\n"
 "\n"
+"    // Layout according to the macOS man page for dir(5).\n"
+"    #[cfg(all(target_os = \"macos\"))]\n"
+"    #[repr(C)]\n"
+"    pub struct dirent {\n"
+"        pub d_fileno: u64,\n"
+"        pub d_seekoff: u64,\n"
+"        pub d_reclen: u16,\n"
+"        pub d_namlen: u16,\n"
+"        pub d_type: u8,\n"
+"        pub d_name: [c_char; 1024],\n"
+"    }\n"
+"\n"
 "    extern \"C\" {\n"
 "        pub fn opendir(s: *const c_char) -> *mut DIR;\n"
+"\n"
+"        #[cfg(not(all(target_os = \"macos\", target_arch = \"x86_64\")))]\n"
 "        pub fn readdir(s: *mut DIR) -> *const dirent;\n"
+"\n"
+"        // See https://github.com/rust-lang/libc/issues/414 and the section "
+"on\n"
+"        // _DARWIN_FEATURE_64_BIT_INODE in the macOS man page for stat(2).\n"
+"        //\n"
+"        // \"Platforms that existed before these updates were available\" "
+"refers\n"
+"        // to macOS (as opposed to iOS / wearOS / etc.) on Intel and "
+"PowerPC.\n"
+"        #[cfg(all(target_os = \"macos\", target_arch = \"x86_64\"))]\n"
+"        #[link_name = \"readdir$INODE64\"]\n"
+"        pub fn readdir(s: *mut DIR) -> *const dirent;\n"
+"\n"
 "        pub fn closedir(s: *mut DIR) -> c_int;\n"
 "    }\n"
 "}\n"
@@ -22235,18 +26627,529 @@ msgid ""
 "    Ok(())\n"
 "}\n"
 "// ANCHOR_END: main\n"
+"\n"
+"#[cfg(test)]\n"
+"mod tests {\n"
+"    use super::*;\n"
+"    use std::error::Error;\n"
+"\n"
+"    #[test]\n"
+"    fn test_nonexisting_directory() {\n"
+"        let iter = DirectoryIterator::new(\"no-such-directory\");\n"
+"        assert!(iter.is_err());\n"
+"    }\n"
+"\n"
+"    #[test]\n"
+"    fn test_empty_directory() -> Result<(), Box<dyn Error>> {\n"
+"        let tmp = tempfile::TempDir::new()?;\n"
+"        let iter = DirectoryIterator::new(\n"
+"            tmp.path().to_str().ok_or(\"Non UTF-8 character in path\")?,\n"
+"        )?;\n"
+"        let mut entries = iter.collect::<Vec<_>>();\n"
+"        entries.sort();\n"
+"        assert_eq!(entries, &[\".\", \"..\"]);\n"
+"        Ok(())\n"
+"    }\n"
+"\n"
+"    #[test]\n"
+"    fn test_nonempty_directory() -> Result<(), Box<dyn Error>> {\n"
+"        let tmp = tempfile::TempDir::new()?;\n"
+"        std::fs::write(tmp.path().join(\"foo.txt\"), \"The Foo "
+"Diaries\\n\")?;\n"
+"        std::fs::write(tmp.path().join(\"bar.png\"), \"<PNG>\\n\")?;\n"
+"        std::fs::write(tmp.path().join(\"crab.rs\"), \"//! Crab\\n\")?;\n"
+"        let iter = DirectoryIterator::new(\n"
+"            tmp.path().to_str().ok_or(\"Non UTF-8 character in path\")?,\n"
+"        )?;\n"
+"        let mut entries = iter.collect::<Vec<_>>();\n"
+"        entries.sort();\n"
+"        assert_eq!(entries, &[\".\", \"..\", \"bar.png\", \"crab.rs\", \"foo."
+"txt\"]);\n"
+"        Ok(())\n"
+"    }\n"
+"}\n"
 "```"
 msgstr ""
 
-#: src/exercises/day-4/solutions-morning.md:1
-msgid "Day 4 Morning Exercise"
-msgstr "4일차 오전 연습문제"
+#: src/exercises/bare-metal/solutions-morning.md:1
+#, fuzzy
+msgid "Bare Metal Rust Morning Exercise"
+msgstr "Bare Metal Rust 오전 연습"
 
-#: src/exercises/day-4/solutions-morning.md:5
+#: src/exercises/bare-metal/solutions-morning.md:5
+msgid "([back to exercise](compass.md))"
+msgstr ""
+
+#: src/exercises/bare-metal/solutions-morning.md:7
+msgid ""
+"```rust,compile_fail\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"// ANCHOR: top\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"extern crate panic_halt as _;\n"
+"\n"
+"use core::fmt::Write;\n"
+"use cortex_m_rt::entry;\n"
+"// ANCHOR_END: top\n"
+"use core::cmp::{max, min};\n"
+"use lsm303agr::{AccelOutputDataRate, Lsm303agr, MagOutputDataRate};\n"
+"use microbit::display::blocking::Display;\n"
+"use microbit::hal::prelude::*;\n"
+"use microbit::hal::twim::Twim;\n"
+"use microbit::hal::uarte::{Baudrate, Parity, Uarte};\n"
+"use microbit::hal::Timer;\n"
+"use microbit::pac::twim0::frequency::FREQUENCY_A;\n"
+"use microbit::Board;\n"
+"\n"
+"const COMPASS_SCALE: i32 = 30000;\n"
+"const ACCELEROMETER_SCALE: i32 = 700;\n"
+"\n"
+"// ANCHOR: main\n"
+"#[entry]\n"
+"fn main() -> ! {\n"
+"    let board = Board::take().unwrap();\n"
+"\n"
+"    // Configure serial port.\n"
+"    let mut serial = Uarte::new(\n"
+"        board.UARTE0,\n"
+"        board.uart.into(),\n"
+"        Parity::EXCLUDED,\n"
+"        Baudrate::BAUD115200,\n"
+"    );\n"
+"\n"
+"    // Set up the I2C controller and Inertial Measurement Unit.\n"
+"    // ANCHOR_END: main\n"
+"    writeln!(serial, \"Setting up IMU...\").unwrap();\n"
+"    let i2c = Twim::new(board.TWIM0, board.i2c_internal.into(), FREQUENCY_A::"
+"K100);\n"
+"    let mut imu = Lsm303agr::new_with_i2c(i2c);\n"
+"    imu.init().unwrap();\n"
+"    imu.set_mag_odr(MagOutputDataRate::Hz50).unwrap();\n"
+"    imu.set_accel_odr(AccelOutputDataRate::Hz50).unwrap();\n"
+"    let mut imu = imu.into_mag_continuous().ok().unwrap();\n"
+"\n"
+"    // Set up display and timer.\n"
+"    let mut timer = Timer::new(board.TIMER0);\n"
+"    let mut display = Display::new(board.display_pins);\n"
+"\n"
+"    let mut mode = Mode::Compass;\n"
+"    let mut button_pressed = false;\n"
+"\n"
+"    // ANCHOR: loop\n"
+"    writeln!(serial, \"Ready.\").unwrap();\n"
+"\n"
+"    loop {\n"
+"        // Read compass data and log it to the serial port.\n"
+"        // ANCHOR_END: loop\n"
+"        while !(imu.mag_status().unwrap().xyz_new_data\n"
+"            && imu.accel_status().unwrap().xyz_new_data)\n"
+"        {}\n"
+"        let compass_reading = imu.mag_data().unwrap();\n"
+"        let accelerometer_reading = imu.accel_data().unwrap();\n"
+"        writeln!(\n"
+"            serial,\n"
+"            \"{},{},{}\\t{},{},{}\",\n"
+"            compass_reading.x,\n"
+"            compass_reading.y,\n"
+"            compass_reading.z,\n"
+"            accelerometer_reading.x,\n"
+"            accelerometer_reading.y,\n"
+"            accelerometer_reading.z,\n"
+"        )\n"
+"        .unwrap();\n"
+"\n"
+"        let mut image = [[0; 5]; 5];\n"
+"        let (x, y) = match mode {\n"
+"            Mode::Compass => (\n"
+"                scale(-compass_reading.x, -COMPASS_SCALE, COMPASS_SCALE, 0, "
+"4) as usize,\n"
+"                scale(compass_reading.y, -COMPASS_SCALE, COMPASS_SCALE, 0, "
+"4) as usize,\n"
+"            ),\n"
+"            Mode::Accelerometer => (\n"
+"                scale(\n"
+"                    accelerometer_reading.x,\n"
+"                    -ACCELEROMETER_SCALE,\n"
+"                    ACCELEROMETER_SCALE,\n"
+"                    0,\n"
+"                    4,\n"
+"                ) as usize,\n"
+"                scale(\n"
+"                    -accelerometer_reading.y,\n"
+"                    -ACCELEROMETER_SCALE,\n"
+"                    ACCELEROMETER_SCALE,\n"
+"                    0,\n"
+"                    4,\n"
+"                ) as usize,\n"
+"            ),\n"
+"        };\n"
+"        image[y][x] = 255;\n"
+"        display.show(&mut timer, image, 100);\n"
+"\n"
+"        // If button A is pressed, switch to the next mode and briefly blink "
+"all LEDs on.\n"
+"        if board.buttons.button_a.is_low().unwrap() {\n"
+"            if !button_pressed {\n"
+"                mode = mode.next();\n"
+"                display.show(&mut timer, [[255; 5]; 5], 200);\n"
+"            }\n"
+"            button_pressed = true;\n"
+"        } else {\n"
+"            button_pressed = false;\n"
+"        }\n"
+"    }\n"
+"}\n"
+"\n"
+"#[derive(Copy, Clone, Debug, Eq, PartialEq)]\n"
+"enum Mode {\n"
+"    Compass,\n"
+"    Accelerometer,\n"
+"}\n"
+"\n"
+"impl Mode {\n"
+"    fn next(self) -> Self {\n"
+"        match self {\n"
+"            Self::Compass => Self::Accelerometer,\n"
+"            Self::Accelerometer => Self::Compass,\n"
+"        }\n"
+"    }\n"
+"}\n"
+"\n"
+"fn scale(value: i32, min_in: i32, max_in: i32, min_out: i32, max_out: i32) -"
+"> i32 {\n"
+"    let range_in = max_in - min_in;\n"
+"    let range_out = max_out - min_out;\n"
+"    cap(\n"
+"        min_out + range_out * (value - min_in) / range_in,\n"
+"        min_out,\n"
+"        max_out,\n"
+"    )\n"
+"}\n"
+"\n"
+"fn cap(value: i32, min_value: i32, max_value: i32) -> i32 {\n"
+"    max(min_value, min(value, max_value))\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/solutions-afternoon.md:5
+msgid "([back to exercise](rtc.md))"
+msgstr ""
+
+#: src/exercises/bare-metal/solutions-afternoon.md:7
+msgid "`main.rs`:"
+msgstr ""
+
+#: src/exercises/bare-metal/solutions-afternoon.md:9
+msgid ""
+"```rust,compile_fail\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"// ANCHOR: top\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"mod exceptions;\n"
+"mod logger;\n"
+"mod pl011;\n"
+"// ANCHOR_END: top\n"
+"mod pl031;\n"
+"\n"
+"use crate::pl031::Rtc;\n"
+"use arm_gic::gicv3::{IntId, Trigger};\n"
+"use arm_gic::{irq_enable, wfi};\n"
+"use chrono::{TimeZone, Utc};\n"
+"use core::hint::spin_loop;\n"
+"// ANCHOR: imports\n"
+"use crate::pl011::Uart;\n"
+"use arm_gic::gicv3::GicV3;\n"
+"use core::panic::PanicInfo;\n"
+"use log::{error, info, trace, LevelFilter};\n"
+"use smccc::psci::system_off;\n"
+"use smccc::Hvc;\n"
+"\n"
+"/// Base addresses of the GICv3.\n"
+"const GICD_BASE_ADDRESS: *mut u64 = 0x800_0000 as _;\n"
+"const GICR_BASE_ADDRESS: *mut u64 = 0x80A_0000 as _;\n"
+"\n"
+"/// Base address of the primary PL011 UART.\n"
+"const PL011_BASE_ADDRESS: *mut u32 = 0x900_0000 as _;\n"
+"// ANCHOR_END: imports\n"
+"\n"
+"/// Base address of the PL031 RTC.\n"
+"const PL031_BASE_ADDRESS: *mut u32 = 0x901_0000 as _;\n"
+"/// The IRQ used by the PL031 RTC.\n"
+"const PL031_IRQ: IntId = IntId::spi(2);\n"
+"\n"
+"// ANCHOR: main\n"
+"#[no_mangle]\n"
+"extern \"C\" fn main(x0: u64, x1: u64, x2: u64, x3: u64) {\n"
+"    // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 "
+"device,\n"
+"    // and nothing else accesses that address range.\n"
+"    let uart = unsafe { Uart::new(PL011_BASE_ADDRESS) };\n"
+"    logger::init(uart, LevelFilter::Trace).unwrap();\n"
+"\n"
+"    info!(\"main({:#x}, {:#x}, {:#x}, {:#x})\", x0, x1, x2, x3);\n"
+"\n"
+"    // Safe because `GICD_BASE_ADDRESS` and `GICR_BASE_ADDRESS` are the "
+"base\n"
+"    // addresses of a GICv3 distributor and redistributor respectively, and\n"
+"    // nothing else accesses those address ranges.\n"
+"    let mut gic = unsafe { GicV3::new(GICD_BASE_ADDRESS, "
+"GICR_BASE_ADDRESS) };\n"
+"    gic.setup();\n"
+"    // ANCHOR_END: main\n"
+"\n"
+"    // Safe because `PL031_BASE_ADDRESS` is the base address of a PL031 "
+"device,\n"
+"    // and nothing else accesses that address range.\n"
+"    let mut rtc = unsafe { Rtc::new(PL031_BASE_ADDRESS) };\n"
+"    let timestamp = rtc.read();\n"
+"    let time = Utc.timestamp_opt(timestamp.into(), 0).unwrap();\n"
+"    info!(\"RTC: {time}\");\n"
+"\n"
+"    GicV3::set_priority_mask(0xff);\n"
+"    gic.set_interrupt_priority(PL031_IRQ, 0x80);\n"
+"    gic.set_trigger(PL031_IRQ, Trigger::Level);\n"
+"    irq_enable();\n"
+"    gic.enable_interrupt(PL031_IRQ, true);\n"
+"\n"
+"    // Wait for 3 seconds, without interrupts.\n"
+"    let target = timestamp + 3;\n"
+"    rtc.set_match(target);\n"
+"    info!(\n"
+"        \"Waiting for {}\",\n"
+"        Utc.timestamp_opt(target.into(), 0).unwrap()\n"
+"    );\n"
+"    trace!(\n"
+"        \"matched={}, interrupt_pending={}\",\n"
+"        rtc.matched(),\n"
+"        rtc.interrupt_pending()\n"
+"    );\n"
+"    while !rtc.matched() {\n"
+"        spin_loop();\n"
+"    }\n"
+"    trace!(\n"
+"        \"matched={}, interrupt_pending={}\",\n"
+"        rtc.matched(),\n"
+"        rtc.interrupt_pending()\n"
+"    );\n"
+"    info!(\"Finished waiting\");\n"
+"\n"
+"    // Wait another 3 seconds for an interrupt.\n"
+"    let target = timestamp + 6;\n"
+"    info!(\n"
+"        \"Waiting for {}\",\n"
+"        Utc.timestamp_opt(target.into(), 0).unwrap()\n"
+"    );\n"
+"    rtc.set_match(target);\n"
+"    rtc.clear_interrupt();\n"
+"    rtc.enable_interrupt(true);\n"
+"    trace!(\n"
+"        \"matched={}, interrupt_pending={}\",\n"
+"        rtc.matched(),\n"
+"        rtc.interrupt_pending()\n"
+"    );\n"
+"    while !rtc.interrupt_pending() {\n"
+"        wfi();\n"
+"    }\n"
+"    trace!(\n"
+"        \"matched={}, interrupt_pending={}\",\n"
+"        rtc.matched(),\n"
+"        rtc.interrupt_pending()\n"
+"    );\n"
+"    info!(\"Finished waiting\");\n"
+"\n"
+"    // ANCHOR: main_end\n"
+"    system_off::<Hvc>().unwrap();\n"
+"}\n"
+"\n"
+"#[panic_handler]\n"
+"fn panic(info: &PanicInfo) -> ! {\n"
+"    error!(\"{info}\");\n"
+"    system_off::<Hvc>().unwrap();\n"
+"    loop {}\n"
+"}\n"
+"// ANCHOR_END: main_end\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/solutions-afternoon.md:149
+msgid "`pl031.rs`:"
+msgstr ""
+
+#: src/exercises/bare-metal/solutions-afternoon.md:151
+msgid ""
+"```rust\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"use core::ptr::{addr_of, addr_of_mut};\n"
+"\n"
+"#[repr(C, align(4))]\n"
+"struct Registers {\n"
+"    /// Data register\n"
+"    dr: u32,\n"
+"    /// Match register\n"
+"    mr: u32,\n"
+"    /// Load register\n"
+"    lr: u32,\n"
+"    /// Control register\n"
+"    cr: u8,\n"
+"    _reserved0: [u8; 3],\n"
+"    /// Interrupt Mask Set or Clear register\n"
+"    imsc: u8,\n"
+"    _reserved1: [u8; 3],\n"
+"    /// Raw Interrupt Status\n"
+"    ris: u8,\n"
+"    _reserved2: [u8; 3],\n"
+"    /// Masked Interrupt Status\n"
+"    mis: u8,\n"
+"    _reserved3: [u8; 3],\n"
+"    /// Interrupt Clear Register\n"
+"    icr: u8,\n"
+"    _reserved4: [u8; 3],\n"
+"}\n"
+"\n"
+"/// Driver for a PL031 real-time clock.\n"
+"#[derive(Debug)]\n"
+"pub struct Rtc {\n"
+"    registers: *mut Registers,\n"
+"}\n"
+"\n"
+"impl Rtc {\n"
+"    /// Constructs a new instance of the RTC driver for a PL031 device at "
+"the\n"
+"    /// given base address.\n"
+"    ///\n"
+"    /// # Safety\n"
+"    ///\n"
+"    /// The given base address must point to the MMIO control registers of "
+"a\n"
+"    /// PL031 device, which must be mapped into the address space of the "
+"process\n"
+"    /// as device memory and not have any other aliases.\n"
+"    pub unsafe fn new(base_address: *mut u32) -> Self {\n"
+"        Self {\n"
+"            registers: base_address as *mut Registers,\n"
+"        }\n"
+"    }\n"
+"\n"
+"    /// Reads the current RTC value.\n"
+"    pub fn read(&self) -> u32 {\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL031 device which is appropriately mapped.\n"
+"        unsafe { addr_of!((*self.registers).dr).read_volatile() }\n"
+"    }\n"
+"\n"
+"    /// Writes a match value. When the RTC value matches this then an "
+"interrupt\n"
+"    /// will be generated (if it is enabled).\n"
+"    pub fn set_match(&mut self, value: u32) {\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL031 device which is appropriately mapped.\n"
+"        unsafe { addr_of_mut!((*self.registers).mr).write_volatile(value) }\n"
+"    }\n"
+"\n"
+"    /// Returns whether the match register matches the RTC value, whether or "
+"not\n"
+"    /// the interrupt is enabled.\n"
+"    pub fn matched(&self) -> bool {\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL031 device which is appropriately mapped.\n"
+"        let ris = unsafe { addr_of!((*self.registers).ris)."
+"read_volatile() };\n"
+"        (ris & 0x01) != 0\n"
+"    }\n"
+"\n"
+"    /// Returns whether there is currently an interrupt pending.\n"
+"    ///\n"
+"    /// This should be true if and only if `matched` returns true and the\n"
+"    /// interrupt is masked.\n"
+"    pub fn interrupt_pending(&self) -> bool {\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL031 device which is appropriately mapped.\n"
+"        let ris = unsafe { addr_of!((*self.registers).mis)."
+"read_volatile() };\n"
+"        (ris & 0x01) != 0\n"
+"    }\n"
+"\n"
+"    /// Sets or clears the interrupt mask.\n"
+"    ///\n"
+"    /// When the mask is true the interrupt is enabled; when it is false "
+"the\n"
+"    /// interrupt is disabled.\n"
+"    pub fn enable_interrupt(&mut self, mask: bool) {\n"
+"        let imsc = if mask { 0x01 } else { 0x00 };\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL031 device which is appropriately mapped.\n"
+"        unsafe { addr_of_mut!((*self.registers).imsc)."
+"write_volatile(imsc) }\n"
+"    }\n"
+"\n"
+"    /// Clears a pending interrupt, if any.\n"
+"    pub fn clear_interrupt(&mut self) {\n"
+"        // Safe because we know that self.registers points to the control\n"
+"        // registers of a PL031 device which is appropriately mapped.\n"
+"        unsafe { addr_of_mut!((*self.registers).icr).write_volatile(0x01) }\n"
+"    }\n"
+"}\n"
+"\n"
+"// Safe because it just contains a pointer to device memory, which can be\n"
+"// accessed from any context.\n"
+"unsafe impl Send for Rtc {}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/solutions-morning.md:1
+#, fuzzy
+msgid "Concurrency Morning Exercise"
+msgstr "3일차 오전 연습문제"
+
+#: src/exercises/concurrency/solutions-morning.md:5
 msgid "([back to exercise](dining-philosophers.md))"
 msgstr ""
 
-#: src/exercises/day-4/solutions-morning.md:7
+#: src/exercises/concurrency/solutions-morning.md:7
 msgid ""
 "```rust\n"
 "// Copyright 2022 Google LLC\n"
@@ -22264,8 +27167,7 @@ msgid ""
 "// limitations under the License.\n"
 "\n"
 "// ANCHOR: Philosopher\n"
-"use std::sync::mpsc;\n"
-"use std::sync::{Arc, Mutex};\n"
+"use std::sync::{mpsc, Arc, Mutex};\n"
 "use std::thread;\n"
 "use std::time::Duration;\n"
 "\n"
@@ -22314,8 +27216,8 @@ msgid ""
 "\n"
 "    for i in 0..forks.len() {\n"
 "        let tx = tx.clone();\n"
-"        let mut left_fork = forks[i].clone();\n"
-"        let mut right_fork = forks[(i + 1) % forks.len()].clone();\n"
+"        let mut left_fork = Arc::clone(&forks[i]);\n"
+"        let mut right_fork = Arc::clone(&forks[(i + 1) % forks.len()]);\n"
 "\n"
 "        // To avoid a deadlock, we have to break the symmetry\n"
 "        // somewhere. This will swap the forks without deinitializing\n"
@@ -22347,470 +27249,485 @@ msgid ""
 "```"
 msgstr ""
 
-#: src/basic-syntax/scalar-types.md:21
-msgid "There are a few syntaxes which are not shown above:"
-msgstr "위에 표시되지 않은 몇 가지 문법이 있습니다."
+#: src/exercises/concurrency/solutions-morning.md:104
+#, fuzzy
+msgid "Link Checker"
+msgstr "멀티스레드 링크 검사기"
 
-#: src/basic-syntax/scalar-types.md:23
-msgid ""
-"Raw strings allow you to create a `&str` value with escapes disabled: "
-"`r\"\\n\" == \"\\\\n\"`. You can embed double-quotes by using an equal "
-"amount of `#` on either side of the quotes:"
+#: src/exercises/concurrency/solutions-morning.md:106
+msgid "([back to exercise](link-checker.md))"
 msgstr ""
-"원시 문자열을 사용하면 이스케이프되지 않는 `&str` 값을 만들 수 있습니다. "
-"`r\"\\n\" == \"\\\\n\"` 따옴표의 양쪽에 같은 양의 `#`을 사용하여 큰따옴표를 "
-"삽입할 수 있습니다."
 
-#: src/basic-syntax/scalar-types.md:27
+#: src/exercises/concurrency/solutions-morning.md:108
 msgid ""
-"```rust,editable\n"
-"fn main() {\n"
-"    println!(r#\"<a href=\"link.html\">link</a>\"#);\n"
-"    println!(\"<a href=\\\"link.html\\\">link</a>\");\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"fn main() {\n"
-"    println!(r#\"<a href=\"link.html\">link</a>\"#);\n"
-"    println!(\"<a href=\\\"link.html\\\">link</a>\");\n"
-"}\n"
-"```"
-
-#: src/basic-syntax/scalar-types.md:34
-msgid "Byte strings allow you to create a `&[u8]` value directly:"
-msgstr "Byte strings allow you to create a `&[u8]` value directly:"
-
-#: src/basic-syntax/scalar-types.md:36
-msgid ""
-"```rust,editable\n"
-"fn main() {\n"
-"    println!(\"{:?}\", b\"abc\");\n"
-"    println!(\"{:?}\", &[97, 98, 99]);\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"fn main() {\n"
-"    println!(\"{:?}\", b\"abc\");\n"
-"    println!(\"{:?}\", &[97, 98, 99]);\n"
-"}\n"
-"```"
-
-#: src/welcome.md:18
-msgid ""
-"The first three days show you the fundamentals of Rust. Following this, "
-"you're invited to dive into one or more specialized topics:"
-msgstr ""
-"처음 3일 동안은 Rust의 기본사항을 살펴봅니다. 그다음에는 다음과 같은 하나 이"
-"상의 전문 주제를 자세히 알아봅니다."
-
-#: src/welcome.md:21
-msgid ""
-"[Android](android.md): a half-day course on using Rust for Android platform "
-"development (AOSP). This includes interoperability with C, C++, and Java."
-msgstr ""
-"[Android](android.md): Android 플랫폼 개발(AOSP) 시 Rust 사용에 관한 반나절 "
-"과정입니다. 여기에는 C, C++, Java와의 상호 운용성이 포함됩니다."
-
-#: src/welcome.md:23
-msgid ""
-"[Bare-metal](bare-metal.md): a full day class on using Rust for bare-metal "
-"(embedded) development. Both microcontrollers and application processors are "
-"covered."
-msgstr ""
-"[Bare-metal](bare-metal.md): bare-metal(임베디드) 개발 시 Rust 사용에 관한 종"
-"일 과정입니다. 마이크로컨트롤러와 애플리케이션 프로세서를 모두 다룹니다."
-
-#: src/welcome.md:26
-msgid ""
-"[Concurrency](concurrency.md): a full day class on concurrency in Rust. We "
-"cover both classical concurrency (preemptively scheduling using threads and "
-"mutexes) and async/await concurrency (cooperative multitasking using "
-"futures)."
-msgstr ""
-"[동시성](concurrency.md): Rust의 동시성에 관한 종일 과정입니다. 여기서는 고전"
-"적인 동시성(스레드와 뮤텍스를 사용하여 선점형 스케줄링을 하는 것)과 async/"
-"await 동시성(future를 사용하는 협력적인 멀티태스킹)을 모두 다룹니다."
-
-#: src/control-flow/if-expressions.md:3
-msgid ""
-"You use [`if` expressions](https://doc.rust-lang.org/reference/expressions/"
-"if-expr.html#if-expressions) exactly like `if` statements in other languages:"
-msgstr ""
-"다른 언어의 `if` 문과 똑같이 [`if` 표현식](https://doc.rust-lang.org/"
-"reference/expressions/if-expr.html#if-expressions)을 사용합니다."
-
-#: src/control-flow/if-let-expressions.md:3
-msgid ""
-"The [`if let` expression](https://doc.rust-lang.org/reference/expressions/if-"
-"expr.html#if-let-expressions) lets you execute different code depending on "
-"whether a value matches a pattern:"
-msgstr ""
-"[`if let` 표현식](https://doc.rust-lang.org/reference/expressions/if-expr."
-"html#if-let-expressions)을 사용하면 값이 패턴과 일치하는지에 따라 다른 코드"
-"를 실행할 수 있습니다."
-
-#: src/control-flow/if-let-expressions.md:26
-msgid ""
-"Since 1.65, a similar [let-else](https://doc.rust-lang.org/rust-by-example/"
-"flow_control/let_else.html) construct allows to do a destructuring "
-"assignment, or if it fails, have a non-returning block branch (panic/return/"
-"break/continue):"
-msgstr ""
-"1.65부터 유사한 [let-else](https://doc.rust-lang.org/rust-by-example/"
-"flow_control/let_else.html) 구성은 디스트럭처링 할당을 실행하거나 실패할 경"
-"우 반환되지 않는 블록 브랜치(panic/return/break/continue)를 보유하도록 허용합"
-"니다."
-
-#: src/control-flow/if-let-expressions.md:28
-msgid ""
-"```rust,editable\n"
-"fn main() {\n"
-"    println!(\"{:?}\", second_word_to_upper(\"foo bar\"));\n"
-"}\n"
-" \n"
-"fn second_word_to_upper(s: &str) -> Option<String> {\n"
-"    let mut it = s.split(' ');\n"
-"    let (Some(_), Some(item)) = (it.next(), it.next()) else {\n"
-"        return None;\n"
-"    };\n"
-"    Some(item.to_uppercase())\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"fn main() {\n"
-"    println!(\"{:?}\", second_word_to_upper(\"foo bar\"));\n"
-"}\n"
-" \n"
-"fn second_word_to_upper(s: &str) -> Option<String> {\n"
-"    let mut it = s.split(' ');\n"
-"    let (Some(_), Some(item)) = (it.next(), it.next()) else {\n"
-"        return None;\n"
-"    };\n"
-"    Some(item.to_uppercase())\n"
-"}\n"
-"```"
-
-#: src/control-flow/while-expressions.md:3
-msgid ""
-"The [`while` keyword](https://doc.rust-lang.org/reference/expressions/loop-"
-"expr.html#predicate-loops) works very similar to other languages:"
-msgstr ""
-"[`while` 키워드](https://doc.rust-lang.org/reference/expressions/loop-expr."
-"html#predicate-loops)는 다른 언어와 매우 비슷하게 작동합니다."
-
-#: src/control-flow/loop-expressions.md:3
-msgid ""
-"Finally, there is a [`loop` keyword](https://doc.rust-lang.org/reference/"
-"expressions/loop-expr.html#infinite-loops) which creates an endless loop."
-msgstr ""
-"마지막으로, 무한 루프를 만드는 [`loop` 키워드](https://doc.rust-lang.org/"
-"reference/expressions/loop-expr.html#infinite-loops)가 있습니다."
-
-#: src/control-flow/loop-expressions.md:28
-msgid ""
-"Note that `loop` is the only looping construct which returns a non-trivial "
-"value. This is because it's guaranteed to be entered at least once (unlike "
-"`while` and `for` loops)."
-msgstr ""
-"`loop`는 non-trivial 값을 반환하는 유일한 반복문입니다. 이는 `while` 및 "
-"`for` 반복문과 달리 최소한 한 번은 루프문을 수행하는 것이 보장되기 때문입니"
-"다."
-
-#: src/control-flow/break-continue.md:3
-msgid ""
-"If you want to exit a loop early, use [`break`](https://doc.rust-lang.org/"
-"reference/expressions/loop-expr.html#break-expressions),"
-msgstr ""
-"루프를 조기에 종료하려면 [`break`](https://doc.rust-lang.org/reference/"
-"expressions/loop-expr.html#break-expressions)를 사용합니다."
-
-#: src/control-flow/break-continue.md:4
-msgid ""
-"If you want to immediately start the next iteration use [`continue`](https://"
-"doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions)."
-msgstr ""
-"다음 반복을 즉시 시작하려면 [`continue`](https://doc.rust-lang.org/reference/"
-"expressions/loop-expr.html#continue-expressions)를 사용합니다."
-
-#: src/SUMMARY.md:34
-msgid "Rustdoc"
-msgstr "Rustdoc"
-
-#: src/SUMMARY.md:147
-msgid "Closures: Fn, FnMut, FnOnce"
-msgstr "클로저: Fn, FnMut, FnOnce"
-
-#: src/SUMMARY.md:212
-msgid "no_std"
-msgstr "no_std"
-
-#: src/SUMMARY.md:214
-msgid "alloc"
-msgstr "alloc"
-
-#: src/SUMMARY.md:217
-msgid "PACs"
-msgstr "PAC"
-
-#: src/SUMMARY.md:218
-msgid "HAL Crates"
-msgstr "HAL 크레이트"
-
-#: src/SUMMARY.md:219
-msgid "Board Support Crates"
-msgstr "보드 지원 크레이트"
-
-#: src/SUMMARY.md:220
-msgid "The Type State Pattern"
-msgstr "Type State 패턴"
-
-#: src/SUMMARY.md:221
-msgid "embedded-hal"
-msgstr "embedded-hal"
-
-#: src/SUMMARY.md:222
-msgid "probe-rs, cargo-embed"
-msgstr "progo-rs, cargo-embed"
-
-#: src/SUMMARY.md:230
-msgid "Application Processors"
-msgstr "애플리케이션 프로세서"
-
-#: src/SUMMARY.md:231
-msgid "Inline Assembly"
-msgstr "인라인 어셈블리"
-
-#: src/SUMMARY.md:232
-msgid "MMIO"
-msgstr "MMIO"
-
-#: src/SUMMARY.md:233
-msgid "Let's Write a UART Driver"
-msgstr "UART 드라이버 작성"
-
-#: src/SUMMARY.md:235
-msgid "A Better UART Driver"
-msgstr "더 나은 UART 드라이버"
-
-#: src/SUMMARY.md:236
-msgid "Bitflags"
-msgstr "비트플래그"
-
-#: src/SUMMARY.md:237
-msgid "Multiple Registers"
-msgstr "더 많은 레지스터"
-
-#: src/SUMMARY.md:238
-msgid "Driver"
-msgstr "드라이버"
-
-#: src/SUMMARY.md:243
-msgid "Useful Crates"
-msgstr "유용한 크레이트"
-
-#: src/SUMMARY.md:244
-msgid "zerocopy"
-msgstr "zerocopy"
-
-#: src/SUMMARY.md:245
-msgid "aarch64-paging"
-msgstr "aarch64-paging"
-
-#: src/SUMMARY.md:246
-msgid "buddy_system_allocator"
-msgstr "buddy_system_allocator"
-
-#: src/SUMMARY.md:247
-msgid "tinyvec"
-msgstr "tinyvec"
-
-#: src/SUMMARY.md:248
-msgid "spin"
-msgstr "회전"
-
-#: src/SUMMARY.md:252
-msgid "RTC Driver"
-msgstr "RTC 드라이버"
-
-#: src/SUMMARY.md:279
-msgid "Async Basics"
-msgstr "비동기 관련 기본사항"
-
-#: src/SUMMARY.md:280
-msgid "async/await"
-msgstr "async/await"
-
-#: src/SUMMARY.md:281
-msgid "Futures"
-msgstr "Future"
-
-#: src/SUMMARY.md:288
-msgid "Select"
-msgstr "Select"
-
-#: src/SUMMARY.md:289
-msgid "Pitfalls"
-msgstr "함정"
-
-#: src/SUMMARY.md:290
-msgid "Blocking the Executor"
-msgstr "Executor 블로킹 하기"
-
-#: src/SUMMARY.md:295
-msgid "Broadcast Chat Application"
-msgstr "채팅 애플리케이션"
-
-#: src/SUMMARY.md:318
-msgid "Bare Metal Rust Morning"
-msgstr "Bare Metal Rust 오전 연습"
-
-#: src/enums.md:6
-msgid ""
-"```rust,editable\n"
-"fn generate_random_number() -> i32 {\n"
-"    // Implementation based on https://xkcd.com/221/\n"
-"    4  // Chosen by fair dice roll. Guaranteed to be random.\n"
-"}\n"
+"```rust,compile_fail\n"
+"// Copyright 2022 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
 "\n"
+"use std::{sync::Arc, sync::Mutex, sync::mpsc, thread};\n"
+"\n"
+"// ANCHOR: setup\n"
+"use reqwest::{blocking::Client, Url};\n"
+"use scraper::{Html, Selector};\n"
+"use thiserror::Error;\n"
+"\n"
+"#[derive(Error, Debug)]\n"
+"enum Error {\n"
+"    #[error(\"request error: {0}\")]\n"
+"    ReqwestError(#[from] reqwest::Error),\n"
+"    #[error(\"bad http response: {0}\")]\n"
+"    BadResponse(String),\n"
+"}\n"
+"// ANCHOR_END: setup\n"
+"\n"
+"// ANCHOR: visit_page\n"
 "#[derive(Debug)]\n"
-"enum CoinFlip {\n"
-"    Heads,\n"
-"    Tails,\n"
+"struct CrawlCommand {\n"
+"    url: Url,\n"
+"    extract_links: bool,\n"
 "}\n"
 "\n"
-"fn flip_coin() -> CoinFlip {\n"
-"    let random_number = generate_random_number();\n"
-"    if random_number % 2 == 0 {\n"
-"        return CoinFlip::Heads;\n"
-"    } else {\n"
-"        return CoinFlip::Tails;\n"
+"fn visit_page(client: &Client, command: &CrawlCommand) -> Result<Vec<Url>, "
+"Error> {\n"
+"    println!(\"Checking {:#}\", command.url);\n"
+"    let response = client.get(command.url.clone()).send()?;\n"
+"    if !response.status().is_success() {\n"
+"        return Err(Error::BadResponse(response.status().to_string()));\n"
 "    }\n"
+"\n"
+"    let mut link_urls = Vec::new();\n"
+"    if !command.extract_links {\n"
+"        return Ok(link_urls);\n"
+"    }\n"
+"\n"
+"    let base_url = response.url().to_owned();\n"
+"    let body_text = response.text()?;\n"
+"    let document = Html::parse_document(&body_text);\n"
+"\n"
+"    let selector = Selector::parse(\"a\").unwrap();\n"
+"    let href_values = document\n"
+"        .select(&selector)\n"
+"        .filter_map(|element| element.value().attr(\"href\"));\n"
+"    for href in href_values {\n"
+"        match base_url.join(href) {\n"
+"            Ok(link_url) => {\n"
+"                link_urls.push(link_url);\n"
+"            }\n"
+"            Err(err) => {\n"
+"                println!(\"On {base_url:#}: ignored unparsable {href:?}: "
+"{err}\");\n"
+"            }\n"
+"        }\n"
+"    }\n"
+"    Ok(link_urls)\n"
+"}\n"
+"// ANCHOR_END: visit_page\n"
+"\n"
+"struct CrawlState {\n"
+"    domain: String,\n"
+"    visited_pages: std::collections::HashSet<String>,\n"
+"}\n"
+"\n"
+"impl CrawlState {\n"
+"    fn new(start_url: &Url) -> CrawlState {\n"
+"        let mut visited_pages = std::collections::HashSet::new();\n"
+"        visited_pages.insert(start_url.as_str().to_string());\n"
+"        CrawlState {\n"
+"            domain: start_url.domain().unwrap().to_string(),\n"
+"            visited_pages,\n"
+"        }\n"
+"    }\n"
+"\n"
+"    /// Determine whether links within the given page should be extracted.\n"
+"    fn should_extract_links(&self, url: &Url) -> bool {\n"
+"        let Some(url_domain) = url.domain() else {\n"
+"            return false;\n"
+"        };\n"
+"        url_domain == self.domain\n"
+"    }\n"
+"\n"
+"    /// Mark the given page as visited, returning true if it had already\n"
+"    /// been visited.\n"
+"    fn mark_visited(&mut self, url: &Url) -> bool {\n"
+"        self.visited_pages.insert(url.as_str().to_string())\n"
+"    }\n"
+"}\n"
+"\n"
+"type CrawlResult = Result<Vec<Url>, (Url, Error)>;\n"
+"fn spawn_crawler_threads(\n"
+"    command_receiver: mpsc::Receiver<CrawlCommand>,\n"
+"    result_sender: mpsc::Sender<CrawlResult>,\n"
+"    thread_count: u32,\n"
+") {\n"
+"    let command_receiver = Arc::new(Mutex::new(command_receiver));\n"
+"\n"
+"    for _ in 0..thread_count {\n"
+"        let result_sender = result_sender.clone();\n"
+"        let command_receiver = command_receiver.clone();\n"
+"        thread::spawn(move || {\n"
+"            let client = Client::new();\n"
+"            loop {\n"
+"                let command_result = {\n"
+"                    let receiver_guard = command_receiver.lock().unwrap();\n"
+"                    receiver_guard.recv()\n"
+"                };\n"
+"                let Ok(crawl_command) = command_result else {\n"
+"                    // The sender got dropped. No more commands coming in.\n"
+"                    break;\n"
+"                };\n"
+"                let crawl_result = match visit_page(&client, &crawl_command) "
+"{\n"
+"                    Ok(link_urls) => Ok(link_urls),\n"
+"                    Err(error) => Err((crawl_command.url, error)),\n"
+"                };\n"
+"                result_sender.send(crawl_result).unwrap();\n"
+"            }\n"
+"        });\n"
+"    }\n"
+"}\n"
+"\n"
+"fn control_crawl(\n"
+"    start_url: Url,\n"
+"    command_sender: mpsc::Sender<CrawlCommand>,\n"
+"    result_receiver: mpsc::Receiver<CrawlResult>,\n"
+") -> Vec<Url> {\n"
+"    let mut crawl_state = CrawlState::new(&start_url);\n"
+"    let start_command = CrawlCommand { url: start_url, extract_links: "
+"true };\n"
+"    command_sender.send(start_command).unwrap();\n"
+"    let mut pending_urls = 1;\n"
+"\n"
+"    let mut bad_urls = Vec::new();\n"
+"    while pending_urls > 0 {\n"
+"        let crawl_result = result_receiver.recv().unwrap();\n"
+"        pending_urls -= 1;\n"
+"\n"
+"        match crawl_result {\n"
+"            Ok(link_urls) => {\n"
+"                for url in link_urls {\n"
+"                    if crawl_state.mark_visited(&url) {\n"
+"                        let extract_links = crawl_state."
+"should_extract_links(&url);\n"
+"                        let crawl_command = CrawlCommand { url, "
+"extract_links };\n"
+"                        command_sender.send(crawl_command).unwrap();\n"
+"                        pending_urls += 1;\n"
+"                    }\n"
+"                }\n"
+"            }\n"
+"            Err((url, error)) => {\n"
+"                bad_urls.push(url);\n"
+"                println!(\"Got crawling error: {:#}\", error);\n"
+"                continue;\n"
+"            }\n"
+"        }\n"
+"    }\n"
+"    bad_urls\n"
+"}\n"
+"\n"
+"fn check_links(start_url: Url) -> Vec<Url> {\n"
+"    let (result_sender, result_receiver) = mpsc::channel::<CrawlResult>();\n"
+"    let (command_sender, command_receiver) = mpsc::channel::"
+"<CrawlCommand>();\n"
+"    spawn_crawler_threads(command_receiver, result_sender, 16);\n"
+"    control_crawl(start_url, command_sender, result_receiver)\n"
 "}\n"
 "\n"
 "fn main() {\n"
-"    println!(\"You got: {:?}\", flip_coin());\n"
+"    let start_url = reqwest::Url::parse(\"https://www.google.org\")."
+"unwrap();\n"
+"    let bad_urls = check_links(start_url);\n"
+"    println!(\"Bad URLs: {:#?}\", bad_urls);\n"
 "}\n"
 "```"
 msgstr ""
-"```rust,editable\n"
-"fn generate_random_number() -> i32 {\n"
-"    // Implementation based on https://xkcd.com/221/\n"
-"    4  // Chosen by fair dice roll. Guaranteed to be random.\n"
+
+#: src/exercises/concurrency/solutions-afternoon.md:1
+#, fuzzy
+msgid "Concurrency Afternoon Exercise"
+msgstr "1일차 오후 연습문제"
+
+#: src/exercises/concurrency/solutions-afternoon.md:5
+msgid "([back to exercise](dining-philosophers-async.md))"
+msgstr ""
+
+#: src/exercises/concurrency/solutions-afternoon.md:7
+msgid ""
+"```rust,compile_fail\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"// ANCHOR: Philosopher\n"
+"use std::sync::Arc;\n"
+"use tokio::time;\n"
+"use tokio::sync::mpsc::{self, Sender};\n"
+"use tokio::sync::Mutex;\n"
+"\n"
+"struct Fork;\n"
+"\n"
+"struct Philosopher {\n"
+"    name: String,\n"
+"    // ANCHOR_END: Philosopher\n"
+"    left_fork: Arc<Mutex<Fork>>,\n"
+"    right_fork: Arc<Mutex<Fork>>,\n"
+"    thoughts: Sender<String>,\n"
 "}\n"
 "\n"
-"#[derive(Debug)]\n"
-"enum CoinFlip {\n"
-"    Heads,\n"
-"    Tails,\n"
-"}\n"
+"// ANCHOR: Philosopher-think\n"
+"impl Philosopher {\n"
+"    async fn think(&self) {\n"
+"        self.thoughts\n"
+"            .send(format!(\"Eureka! {} has a new idea!\", &self.name))."
+"await\n"
+"            .unwrap();\n"
+"    }\n"
+"    // ANCHOR_END: Philosopher-think\n"
 "\n"
-"fn flip_coin() -> CoinFlip {\n"
-"    let random_number = generate_random_number();\n"
-"    if random_number % 2 == 0 {\n"
-"        return CoinFlip::Heads;\n"
-"    } else {\n"
-"        return CoinFlip::Tails;\n"
+"    // ANCHOR: Philosopher-eat\n"
+"    async fn eat(&self) {\n"
+"        // Pick up forks...\n"
+"        // ANCHOR_END: Philosopher-eat\n"
+"        let _first_lock = self.left_fork.lock().await;\n"
+"        // Add a delay before picking the second fork to allow the "
+"execution\n"
+"        // to transfer to another task\n"
+"        time::sleep(time::Duration::from_millis(1)).await;\n"
+"        let _second_lock = self.right_fork.lock().await;\n"
+"\n"
+"        // ANCHOR: Philosopher-eat-body\n"
+"        println!(\"{} is eating...\", &self.name);\n"
+"        time::sleep(time::Duration::from_millis(5)).await;\n"
+"        // ANCHOR_END: Philosopher-eat-body\n"
+"\n"
+"        // The locks are dropped here\n"
+"        // ANCHOR: Philosopher-eat-end\n"
 "    }\n"
 "}\n"
 "\n"
-"fn main() {\n"
-"    println!(\"You got: {:?}\", flip_coin());\n"
-"}\n"
-"```"
-
-#: src/basic-syntax/rustdoc.md:3
-msgid ""
-"All language items in Rust can be documented using special `///` syntax."
-msgstr "Rust의 아이템(item)은 `///` 문법을 사용하여 문서화할 수 있습니다."
-
-#: src/basic-syntax/rustdoc.md:5
-msgid ""
-"```rust,editable\n"
-"/// Determine whether the first argument is divisible by the second "
-"argument.\n"
-"///\n"
-"/// If the second argument is zero, the result is false.\n"
-"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
-"    if rhs == 0 {\n"
-"        return false;  // Corner case, early return\n"
+"static PHILOSOPHERS: &[&str] =\n"
+"    &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+"    // ANCHOR_END: Philosopher-eat-end\n"
+"    // Create forks\n"
+"    let mut forks = vec![];\n"
+"    (0..PHILOSOPHERS.len()).for_each(|_| forks.push(Arc::new(Mutex::"
+"new(Fork))));\n"
+"\n"
+"    // Create philosophers\n"
+"    let (philosophers, mut rx) = {\n"
+"        let mut philosophers = vec![];\n"
+"        let (tx, rx) = mpsc::channel(10);\n"
+"        for (i, name) in PHILOSOPHERS.iter().enumerate() {\n"
+"            let left_fork = Arc::clone(&forks[i]);\n"
+"            let right_fork = Arc::clone(&forks[(i + 1) % PHILOSOPHERS."
+"len()]);\n"
+"            // To avoid a deadlock, we have to break the symmetry\n"
+"            // somewhere. This will swap the forks without deinitializing\n"
+"            // either of them.\n"
+"            if i  == 0 {\n"
+"                std::mem::swap(&mut left_fork, &mut right_fork);\n"
+"            }\n"
+"            philosophers.push(Philosopher {\n"
+"                name: name.to_string(),\n"
+"                left_fork,\n"
+"                right_fork,\n"
+"                thoughts: tx.clone(),\n"
+"            });\n"
+"        }\n"
+"        (philosophers, rx)\n"
+"        // tx is dropped here, so we don't need to explicitly drop it later\n"
+"    };\n"
+"\n"
+"    // Make them think and eat\n"
+"    for phil in philosophers {\n"
+"        tokio::spawn(async move {\n"
+"            for _ in 0..100 {\n"
+"                phil.think().await;\n"
+"                phil.eat().await;\n"
+"            }\n"
+"        });\n"
+"\n"
 "    }\n"
-"    lhs % rhs == 0     // The last expression in a block is the return "
-"value\n"
-"}\n"
-"```"
-msgstr ""
-"```rust,editable\n"
-"/// 첫 번째 인수가 두 번째 인수로 나눠질 수 있는지 결정합니다.\n"
-"///\n"
-"/// 두 번째 인수가 0이면 결과는 false입니다.\n"
-"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
-"    if rhs == 0 {\n"
-"        return false;  // Corner case, early return\n"
+"\n"
+"    // Output their thoughts\n"
+"    while let Some(thought) = rx.recv().await {\n"
+"        println!(\"Here is a thought: {thought}\");\n"
 "    }\n"
-"    lhs % rhs == 0     // 블록 안의 마지막 표현식은 반환값입니다\n"
-"}\n"
-"```"
-
-#: src/basic-syntax/rustdoc.md:17
-msgid ""
-"The contents are treated as Markdown. All published Rust library crates are "
-"automatically documented at [`docs.rs`](https://docs.rs) using the [rustdoc]"
-"(https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It is "
-"idiomatic to document all public items in an API using this pattern."
-msgstr ""
-"콘텐츠는 마크다운으로 처리됩니다. 게시된 모든 Rust 라이브러리 크레이트는 "
-"[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) 도구를 사용"
-"하여 [`docs.rs`](https://docs.rs)에 자동으로 문서화됩니다. 일반적으로 API의 "
-"모든 공개 항목은 이 패턴을 사용하여 문서화됩니다."
-
-#: src/basic-syntax/rustdoc.md:24
-msgid ""
-"Show students the generated docs for the `rand` crate at [`docs.rs/rand`]"
-"(https://docs.rs/rand)."
-msgstr ""
-"[`docs.rs/rand`](https://docs.rs/rand)에서 `rand` 크레이트용으로 생성된 문서"
-"를 학생에게 보여줍니다."
-
-#: src/basic-syntax/rustdoc.md:27
-msgid ""
-"This course does not include rustdoc on slides, just to save space, but in "
-"real code they should be present."
-msgstr ""
-"이 과정에서는 공간 절약을 위해 슬라이드에 rustdoc을 포함하지 않지만 실제 코드"
-"에는 존재해야 합니다."
-
-#: src/basic-syntax/rustdoc.md:30
-msgid ""
-"Inner doc comments are discussed later (in the page on modules) and need not "
-"be addressed here."
-msgstr ""
-"내부 문서 주석은 모듈 페이지 뒷부분에서 다루며 여기서 다루지 않아도 됩니다."
-
-#: src/basic-syntax/methods.md:34
-msgid "Add a `Rectangle::new` constructor and call this from `main`:"
-msgstr "`Rectangle::new` 생성자를 추가하고 이를 `main`에서 호출합니다."
-
-#: src/basic-syntax/methods.md:36
-msgid ""
-"```rust,editable,compile_fail\n"
-"fn new(width: u32, height: u32) -> Rectangle {\n"
-"    Rectangle { width, height }\n"
 "}\n"
 "```"
 msgstr ""
-"```rust,editable,compile_fail\n"
-"fn new(width: u32, height: u32) -> Rectangle {\n"
-"    Rectangle { width, height }\n"
+
+#: src/exercises/concurrency/solutions-afternoon.md:121
+msgid "([back to exercise](chat-app.md))"
+msgstr ""
+
+#: src/exercises/concurrency/solutions-afternoon.md:125
+msgid ""
+"```rust,compile_fail\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"// ANCHOR: setup\n"
+"use futures_util::sink::SinkExt;\n"
+"use std::error::Error;\n"
+"use std::net::SocketAddr;\n"
+"use tokio::net::{TcpListener, TcpStream};\n"
+"use tokio::sync::broadcast::{channel, Sender};\n"
+"use tokio_websockets::{Message, ServerBuilder, WebsocketStream};\n"
+"// ANCHOR_END: setup\n"
+"\n"
+"// ANCHOR: handle_connection\n"
+"async fn handle_connection(\n"
+"    addr: SocketAddr,\n"
+"    mut ws_stream: WebsocketStream<TcpStream>,\n"
+"    bcast_tx: Sender<String>,\n"
+") -> Result<(), Box<dyn Error + Send + Sync>> {\n"
+"    // ANCHOR_END: handle_connection\n"
+"\n"
+"    ws_stream\n"
+"        .send(Message::text(\"Welcome to chat! Type a message\".into()))\n"
+"        .await?;\n"
+"    let mut bcast_rx = bcast_tx.subscribe();\n"
+"\n"
+"    // A continuous loop for concurrently performing two tasks: (1) "
+"receiving\n"
+"    // messages from `ws_stream` and broadcasting them, and (2) receiving\n"
+"    // messages on `bcast_rx` and sending them to the client.\n"
+"    loop {\n"
+"        tokio::select! {\n"
+"            incoming = ws_stream.next() => {\n"
+"                match incoming {\n"
+"                    Some(Ok(msg)) => {\n"
+"                        let msg = msg.as_text()?;\n"
+"                        println!(\"From client {addr:?} {msg:?}\");\n"
+"                        bcast_tx.send(msg.into())?;\n"
+"                    }\n"
+"                    Some(Err(err)) => return Err(err.into()),\n"
+"                    None => return Ok(()),\n"
+"                }\n"
+"            }\n"
+"            msg = bcast_rx.recv() => {\n"
+"                ws_stream.send(Message::text(msg?)).await?;\n"
+"            }\n"
+"        }\n"
+"    }\n"
+"    // ANCHOR: main\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {\n"
+"    let (bcast_tx, _) = channel(16);\n"
+"\n"
+"    let listener = TcpListener::bind(\"127.0.0.1:2000\").await?;\n"
+"    println!(\"listening on port 2000\");\n"
+"\n"
+"    loop {\n"
+"        let (socket, addr) = listener.accept().await?;\n"
+"        println!(\"New connection from {addr:?}\");\n"
+"        let bcast_tx = bcast_tx.clone();\n"
+"        tokio::spawn(async move {\n"
+"            // Wrap the raw TCP stream into a websocket.\n"
+"            let ws_stream = ServerBuilder::new().accept(socket).await?;\n"
+"\n"
+"            handle_connection(addr, ws_stream, bcast_tx).await\n"
+"        });\n"
+"    }\n"
+"}\n"
+"// ANCHOR_END: main\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/solutions-afternoon.md:210
+msgid ""
+"```rust,compile_fail\n"
+"// Copyright 2023 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License.\n"
+"\n"
+"// ANCHOR: setup\n"
+"use futures_util::SinkExt;\n"
+"use http::Uri;\n"
+"use tokio::io::{AsyncBufReadExt, BufReader};\n"
+"use tokio_websockets::{ClientBuilder, Message};\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> Result<(), tokio_websockets::Error> {\n"
+"    let mut ws_stream = ClientBuilder::from_uri(Uri::"
+"from_static(\"ws://127.0.0.1:2000\"))\n"
+"        .connect()\n"
+"        .await?;\n"
+"\n"
+"    let stdin = tokio::io::stdin();\n"
+"    let mut stdin = BufReader::new(stdin).lines();\n"
+"\n"
+"    // ANCHOR_END: setup\n"
+"    // Continuous loop for concurrently sending and receiving messages.\n"
+"    loop {\n"
+"        tokio::select! {\n"
+"            incoming = ws_stream.next() => {\n"
+"                match incoming {\n"
+"                    Some(Ok(msg)) => println!(\"From server: {}\", msg."
+"as_text()?),\n"
+"                    Some(Err(err)) => return Err(err.into()),\n"
+"                    None => return Ok(()),\n"
+"                }\n"
+"            }\n"
+"            res = stdin.next_line() => {\n"
+"                match res {\n"
+"                    Ok(None) => return Ok(()),\n"
+"                    Ok(Some(line)) => ws_stream.send(Message::text(line."
+"to_string())).await?,\n"
+"                    Err(err) => return Err(err.into()),\n"
+"                }\n"
+"            }\n"
+"\n"
+"        }\n"
+"    }\n"
 "}\n"
 "```"
-
-#: src/basic-syntax/methods.md:42
-msgid ""
-"Add a `Rectangle::new_square(width: u32)` constructor to illustrate that "
-"constructors can take arbitrary parameters."
 msgstr ""
-"`Rectangle::new_square(width: u32)` 생성자를 추가하여 생성자가 임의의 매개변"
-"수를 사용할 수 있음을 보여줍니다."