CF

Practical TypeScript: Foundations to Fluency

9h 18m 45s
English
Paid

Practical TypeScript: Foundations to Fluency helps you understand how TypeScript works, not just how to write code with types. You learn clear ideas you can use right away.

What You Learn

You build a simple mental model of the type system. This helps you see why errors appear and how to fix them with ease. You learn how to use generics, work with unknown, and write types that stop bugs before they reach runtime.

How the Course Flows

The course has five modules. You start with core ideas about typed code and structured data. You then move to advanced tools like constrained generics, conditional types, utility types, async code, and modular design. Each topic builds on the last. You see each idea in practice, with no hidden “magic.”

Work With AI Code

You learn to read and check code from AI tools. You spot weak type choices and make clear fixes. This helps you shape safe designs even when the code comes from a model.

Skills You Build

  • Strong confidence when you use the type system
  • The skill to read and explain compiler messages
  • Knowledge of key patterns like discriminated unions and type guards
  • A base that makes later TypeScript topics much easier

Who This Course Helps

This course is for you if you want to stop guessing at errors and start understanding why your code works. You do not memorize keywords. You learn clear ideas that guide you in real projects.

Additional

Modules

  • 1. Programming Foundations
  • 2. Structured Data
  • 3. Type Safety
  • 4. Object Oriented TypeScript
  • 5. Advanced TypeScript

About the Author: Kent C. Dodds

Kent C. Dodds thumbnail

Kent C. Dodds is a US developer and one of the most influential modern voices on JavaScript testing and the React ecosystem. He is the creator of Testing Library (the de-facto standard for testing React components), EpicReact.dev, EpicWeb.dev, and previously authored the Testing JavaScript course on egghead.io. His teaching has anchored a generation of React developers' approach to component testing and modern React patterns.

His paid course catalog covers React in depth (Epic React: hooks, advanced patterns, performance, suspense, the App Router era), the testing tracks (Epic Web's testing course, the original Testing JavaScript material), TypeScript with React, and the broader full-stack JavaScript craft. Material is taught at the level of a working senior React engineer.

The CourseFlix listing under this source carries 5 Kent C. Dodds courses spanning that range. Material is paid; Kent's courses run on per-course or membership pricing on the original platforms (EpicWeb / EpicReact). Courses are aimed at intermediate-and-up React developers.

Watch Online 250 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 250 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: 1.1. Intro to Introduction To Programming Foundations
All Course Lessons (250)
#Lesson TitleDurationAccess
1
1.1. Intro to Introduction To Programming Foundations Demo
06:46
2
1.2. Intro to Expressions And Output
02:18
3
1.3. Hello World - Problem
02:07
4
1.4. Hello World - Solution
08:30
5
1.5. Escaping Strings - Problem
01:11
6
1.6. Escaping Strings - Solution
03:25
7
1.7. Strings - Problem
00:32
8
1.8. Strings - Solution
01:47
9
1.9. Numbers - Problem
00:25
10
1.10. Numbers - Solution
01:57
11
1.11. Template Literals - Problem
00:48
12
1.12. Template Literals - Solution
03:53
13
1.13. Break
01:05
14
1.14. Intro to Variables
02:39
15
1.15. Let And Const - Problem
00:54
16
1.16. Let And Const - solution
09:01
17
1.17. Reassignment Vs Mutation - Problem
00:55
18
1.18. Reassignment Vs Mutation - solution
03:03
19
1.19. Break Variables
01:05
20
1.20. Intro to Primitive Types
04:01
21
1.21. Numbers And Strings - Problem
00:31
22
1.22. Numbers And Strings - solution
02:43
23
1.23. Comparisons - Problem
00:30
24
1.24. Comparisons - solution
05:56
25
1.25. Booleans And Comparisons - Problem
00:31
26
1.26. Booleans And Comparisons - solution
03:50
27
1.27. Null And Undefined - Problem
00:33
28
1.28. Null And Undefined - solution
03:28
29
1.29. Bigint And Symbol - Problem
00:42
30
1.30. Bigint And Symbol - solution
04:57
31
1.31. Truthy Falsy - Problem
01:04
32
1.32. Truthy Falsy - solution
10:33
33
1.33. Break Primitive Types
00:37
34
1.34. Intro to Control Flow
05:28
35
1.35. Conditionals - Problem
00:17
36
1.36. Conditionals - solution
04:40
37
1.37. Switch Stateme - Problem
00:53
38
1.38. Switch Stateme - solution
10:29
39
1.39. Loops - Problem
00:44
40
1.40. Loops - solution
04:40
41
1.41. Nested Loops - Problem
00:52
42
1.42. Nested Loops - solution
06:22
43
1.43. Ternary Operator - Problem
00:39
44
1.44. Ternary Operator - solution
04:47
45
1.45. Errors - Problem
00:45
46
1.46. Errors - solution
02:45
47
1.47. Break Control Flow
00:37
48
1.48. Intro to Functions
04:42
49
1.49. Function Declaration - Problem
00:35
50
1.50. Function Declaration - solution
02:23
51
1.51. Parameters - Problem
01:03
52
1.52. Parameters - solution
04:25
53
1.53. Type Inference - Problem
00:32
54
1.54. Type Inference - solution
04:33
55
1.55. Arrow Functions - Problem
00:55
56
1.56. Arrow Functions - solution
10:57
57
1.57. Jsdoc - Problem
00:41
58
1.58. Jsdoc - solution
03:33
59
1.59. Break Functions
00:39
60
1.60. Intro to Void And Never
01:23
61
1.61. Void Functions - Problem
00:38
62
1.62. Void Functions - solution
04:22
63
1.63. Never Type - Problem
00:50
64
1.64. Never Type - solution
05:32
65
1.65. Break Void and Never
00:45
66
1.66. Outro To Programming Foundations
00:39
67
2.1. Intro to Structured Data
02:14
68
2.2. Intro to Obje
01:12
69
2.3. Object Literals - Problem
00:19
70
2.4. Object Literals - solution
01:47
71
2.5. Property Access - Problem
00:14
72
2.6. Property Access - solution
03:56
73
2.7. Object Types - Problem
00:25
74
2.8. Object Types - solution
01:11
75
2.9. Optional Properties - Problem
00:29
76
2.10. Optional Properties - solution
08:08
77
2.11. Dynamic Keys - Problem
00:40
78
2.12. Dynamic Keys - solution
02:14
79
2.13. Break Obje
00:49
80
2.14. Intro to Arrays
02:11
81
2.15. Array Basics - Problem
00:22
82
2.16. Array Basics - solution
04:13
83
2.17. Array Types - Problem
00:17
84
2.18. Array Types - solution
05:00
85
2.19. Iteration - Problem
00:28
86
2.20. Iteration - solution
01:46
87
2.21. Break Arrays
01:16
88
2.22. Intro to Spread and Rest
02:02
89
2.23. Object Spread - Problem
00:49
90
2.24. Object Spread - solution
10:45
91
2.25. Rest Parameters - Problem
00:41
92
2.26. Rest Parameters - solution
05:41
93
2.27. Break Spread and Rest
00:38
94
2.28. Intro to Destructuring
01:20
95
2.29. Object Destructuring - Problem
00:53
96
2.30. Object Destructuring - solution
09:12
97
2.31. Array Destructuring - Problem
00:17
98
2.32. Array Destructuring - solution
04:28
99
2.33. Outro
01:04
100
2.34. Intro to Array Methods
02:19
101
2.35. Map - Problem
00:28
102
2.36. Map - solution
07:18
103
2.37. Filter - Problem
00:21
104
2.38. Filter - solution
06:51
105
2.39. Reduce - Problem
00:54
106
2.40. Reduce - solution
11:04
107
2.41. Break Array Methods
01:16
108
2.42. Intro to .object-methods
01:22
109
2.43. Keys Values - Problem
00:22
110
2.44. Keys Values - solution
02:40
111
2.45. Entries From Entries - Problem
00:24
112
2.46. Entries From Entries - solution
02:00
113
2.47. Break Object Methods
00:30
114
2.48. Intro to Maps and S
02:25
115
2.49. Maps - Problem
00:32
116
2.50. Maps - solution
05:24
117
2.51. S - Problem
00:39
118
2.52. S - solution
03:49
119
2.53. Break Maps and S
00:36
120
2.54. Outro to Structured Data
00:52
121
3.1. Intro to Type Safety
01:20
122
3.2. Intro to Type Aliases
01:53
123
3.3. Naming Types - solution
04:34
124
3.4. Composition - solution
02:13
125
3.5. Record Type - Problem
00:36
126
3.6. Record Type - solution
02:38
127
3.7. Break Type Aliases
01:02
128
3.8. Intro to Union Types
03:23
129
3.9. Multiple Types - Problem
00:28
130
3.10. Multiple Types - solution
03:05
131
3.11. Narrowing - Problem
00:25
132
3.12. Narrowing - solution
04:21
133
3.13. Type Guards - Problem
00:45
134
3.14. Type Guards - solution
03:17
135
3.15. Discriminated Unions - Problem
00:21
136
3.16. Discriminated Unions - solution
07:09
137
3.17. Break Union Types
00:47
138
3.18. Intro to Literal Types
02:12
139
3.19. Preserve Literals - Problem
00:16
140
3.20. Preserve Literals - solution
06:21
141
3.21. Single Source Of Truth - Problem
00:26
142
3.22. Single Source Of Truth - solution
03:10
143
3.23. Break Literal Types
00:43
144
3.24. Intro to Intersection Types
01:10
145
3.25. Combining Types - Problem
00:13
146
3.26. Combining Types - solution
02:24
147
3.27. Break Intersection Types
00:37
148
3.28. Intro to Any vs Unknown
00:55
149
3.29. Escape Hatches - Problem
00:23
150
3.30. Escape Hatches - solution
03:36
151
3.31. Break Any vs Unknown
00:41
152
3.32. Intro to Generics
02:09
153
3.33. Generic Functions - Problem
00:32
154
3.34. Generic Functions - solution
05:23
155
3.35. Generic Types - Problem
00:17
156
3.36. Generic Types - solution
04:06
157
3.37. Constrai - Problem
00:57
158
3.38. Constrai - solution
07:38
159
3.39. Break Generics
00:34
160
3.40. Intro to Interfaces
01:19
161
3.41. Object Shapes - Problem
00:19
162
3.42. Object Shapes - solution
01:39
163
3.43. Extending Interfaces - Problem
00:20
164
3.44. Extending Interfaces - solution
02:23
165
3.45. Declaration Merging - Problem
00:47
166
3.46. Declaration Merging - solution
04:28
167
3.47. Break Interfaces
00:50
168
3.48. Intro to Enums
01:21
169
3.49. String Enums - Problem
00:21
170
3.50. String Enums - solution
03:47
171
3.51. Enum Vs Union - Problem
00:32
172
3.52. Enum Vs Union - solution
02:01
173
3.53. Break Enums
00:36
174
3.54. Outro to Type Safety
00:51
175
4.1. Intro to Object Oriented TypeScript
00:45
176
4.2. Intro to Classes
01:19
177
4.3. Class Basics - Problem
00:29
178
4.4. Class Basics - solution
06:53
179
4.5. Private Fields And Defau - Problem
00:23
180
4.6. Private Fields And Defau - solution
07:33
181
4.7. Break Classes
00:37
182
4.8. Intro to Interfaces and Classes
00:58
183
4.9. Implementing Interfaces - Problem
00:16
184
4.10. Implementing Interfaces - solution
03:21
185
4.11. Programming To Abstractions - Problem
00:10
186
4.12. Programming To Abstractions - solution
00:53
187
4.13. Break Interfaces and Classes
00:33
188
4.14. Intro to Inheritance and Polymorphism - Epic Web Dev
02:38
189
4.15. Extends - Problem
00:25
190
4.16. Extends - solution
04:21
191
4.17. Method Overriding - Problem
00:24
192
4.18. Method Overriding - solution
01:09
193
4.19. Substitutability - Problem
00:26
194
4.20. Substitutability - solution
00:39
195
4.21. Break Inheritance and Polymorphism
00:52
196
4.22. Intro to Composition vs Inheritance
03:10
197
4.23. When To Use - Problem
00:20
198
4.24. When To Use - solution
02:52
199
4.25. Dependency Injection - Problem
00:30
200
4.26. Dependency Injection (Solution) - solution
03:46
201
4.27. Break Composition vs Inheritance
00:36
202
4.28. Outro to Object Oriented TypeScript
00:34
203
5.1. Intro to Advanced TypeScript
01:44
204
5.2. Intro to Promises
06:20
205
5.3. Creation - Problem
01:03
206
5.4. Creation - solution
05:50
207
5.5. Chaining - Problem
00:31
208
5.6. Chaining - solution
04:18
209
5.7. Rejection - Problem
00:42
210
5.8. Rejection - solution
07:06
211
5.9. Break Promises
00:59
212
5.10. Intro to Async-Await
01:23
213
5.11. Linear Flow - Problem
00:35
214
5.12. Linear Flow - solution
04:11
215
5.13. Error Handling - Problem
00:15
216
5.14. Error Handling - solution
02:24
217
5.15. Promise Types - Problem
00:13
218
5.16. Promise Types - solution
04:03
219
5.17. Break Async-Await
00:46
220
5.18. Intro to Modules
00:57
221
5.19. Import Export - Problem
00:24
222
5.20. Import Export - solution
03:35
223
5.21. Default Vs Named - Problem
00:18
224
5.22. Default Vs Named - solution
03:37
225
5.23. Type Only Impo - Problem
00:16
226
5.24. Type Only Impo - solution
02:40
227
5.25. Break Modules
01:02
228
5.26. Intro to Type Operators
01:10
229
5.27. Keyof Typeof - Problem
00:22
230
5.28. Keyof Typeof - solution
03:40
231
5.29. Index Access - Problem
00:19
232
5.30. Index Access - solution
02:46
233
5.31. Break Type Operators
00:36
234
5.32. Intro to Utility Types
00:56
235
5.33. Partial Pick - Problem
00:19
236
5.34. Partial Pick - solution
02:37
237
5.35. More Utilities - Problem
00:13
238
5.36. More Utilities - solution
03:21
239
5.37. Function Utilities - Problem
00:16
240
5.38. Function Utilities - solution
05:02
241
5.39. Creating Mapped Types - Problem
00:34
242
5.40. Creating Mapped Types - solution
03:23
243
5.41. Break Utility Types
00:38
244
5.42. Intro to Conditional Types
01:32
245
5.43. Basic Conditionals - Problem
00:18
246
5.44. Basic Conditionals - solution
04:34
247
5.45. Infer - Problem
00:17
248
5.46. Infer - solution
02:51
249
5.47. Break Conditional Types
00:41
250
5.48. Outro to Advanced TypeScript
01:13
Unlock unlimited learning

Get instant access to all 249 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for this TypeScript course?
The course does not specify any formal prerequisites, but having a basic understanding of programming concepts is beneficial. Early lessons cover foundational topics like expressions, variables, and control flow, which suggests that a beginner in programming could follow along. Familiarity with JavaScript could also be helpful given TypeScript's relationship to it.
What projects or exercises will I build during the course?
Throughout the course, you will engage in exercises that focus on understanding and applying TypeScript's type system. For example, you start with foundational exercises such as 'Hello World' and move towards more complex topics like discriminated unions and type guards. The course emphasizes practical application through exercises that reinforce each module's lessons.
Who is the target audience for this TypeScript course?
This course is targeted at learners who wish to deepen their understanding of TypeScript beyond basic syntax. It's ideal for those who want to grasp why certain errors occur and how to resolve them effectively. If you're looking to strengthen your ability to work with TypeScript in real-world projects, this course is suited for you.
How does this course compare in depth to other TypeScript courses?
This course offers a detailed exploration of TypeScript, focusing on building a mental model of the type system and practical skills like reading compiler messages and working with AI-generated code. Its comprehensive approach to advanced topics like generics, conditional types, and modular design sets it apart from more introductory courses.
What specific TypeScript tools or features are covered in the course?
The course covers a range of TypeScript tools and features, including generics, constrained generics, conditional types, utility types, and async code. It also explores key patterns such as discriminated unions and type guards, providing a thorough understanding of the TypeScript type system.
What topics or skills are not covered in this TypeScript course?
While the course provides a strong foundation in TypeScript's type system and advanced features, it does not cover certain topics such as frontend frameworks or server-side TypeScript applications. The focus remains on understanding and applying the type system effectively.
What is the expected time commitment for completing this course?
The course consists of 250 lessons, ranging from foundational programming concepts to advanced TypeScript features. While the exact runtime is unspecified, given the extensive content, learners should expect to dedicate a significant amount of time to fully engage with the material and complete the exercises.