Top 8 Recommended TypeScript Self-Study Materials! [November 2024]

Welcome to the best resource online for mastering TypeScript.

TypeScript is a powerful superset of JavaScript that makes development smoother, safer, and helps you catch errors and avoid bugs early on. TypeScript adds a bunch of useful features to the JavaScript that you know and love. It helps you be a more productive developer and forces you to write better code.

TypeScript has skyrocketed in popularity to become one of the world’s most popular and loved programming languages. It has doubled in popularity every year since 2017, and it continues to grow at an astronomical rate. It’s definitely the right time to learn TypeScript!

This course covers all the syntax, features, and concepts you need to master TypeScript and start using it in your own codebases. We start with the very basics of the type system and cover everything up to incorporating TypeScript in React codebases and using Webpack with TypeScript.

Here’s a detailed breakdown of the topics the course covers:

• The TypeScript type system

• Union Types

• Intersection Types

• Tuples and Enums

• Interfaces

• The TypeScript compiler and how to configure it

• Working with the DOM and TypeScript

• TypeScript Classes

• Generics

• Type Narrowing

• Type Declarations

• Working with 3rd party libraries

• Webpack + TypeScript workflows

• Integrating React and TypeScript

• TypeScript’s Module System

Enroll in this course to learn what TypeScript is, why it’s so popular, and how to use it!

1. Introduction
2. Welcome & Course Overview
3. Join The Community!
4. Course Prerequisites
5. The Case For TypeScript
6. TypeScript Overview
7. GET THE COURSE SLIDES!
8. Installation & Setup
9. Installing TypeScript
10. The TypeScript Playground
11. Installing Visual Studio Code
12. How We Use TypeScript
13. Type Annotation Basics
14. Our First Type Annotation
15. Working With Numbers & Booleans
16. Super Quick Quiz!
17. Compiling TypeScript
18. Type Inference
19. The Any Type
20. Delayed Initialization & Implicit Any
21. Inference Quiz
22. Functions
23. Function Parameter Annotations
24. Function Parameter Quiz
25. More On Function Parameter Annotations
26. Working With Default Parameters
27. Return Type Annotations
28. Anonymous Function Contextual Typing
29. The Void Type
30. Return Type Quiz
31. The Never Type
32. Function Types EXERCISE
33. Object Types
34. Working With Object Types
35. More Object Types
36. Excess Properties
37. Object Types Quiz
38. Creating Type Aliases
39. Nested Objects
40. Optional Properties
41. The readonly Modifier
42. Intersection Types
43. Object Types EXERCISE
44. Array Types
45. Working With Array Types
46. More Array Syntax
47. Multidimensional Arrays
48. Array Types EXERCISE
49. Union Types
50. Introducing Union Types
51. Type Narrowing w/ Union Types
52. Union Types and Arrays
53. Literal Types
54. Union Types EXERCISE
55. Tuples and Enums
56. Introducing Tuples
57. A Bit More On Tuples
58. Tuples Quiz
59. NOTE: About The Slides In The Upcoming Lecture
60. Introducing Enums
61. A Bit More On Enums!
62. Enums Behind The Scenes
63. Interfaces
64. Introducing Interfaces
65. Readonly and Optional Interface Properties
66. Interface Methods
67. Interface Method Parameters
68. Interface Methods Quiz
69. Reopening Interfaces
70. Extending Interfaces
71. Interface Multiple Inheritance
72. Interfaces Vs. Type Aliases
73. The TypeScript Compiler
74. Compiling to JavaScript
75. Watch Mode
76. Working With Multiple Files
77. The Files Compiler Option
78. Include & Exclude Options
79. Outdir Option
80. Target Option
81. Strict Option
82. Compiler Options Wrap Up
83. Mini Project: The DOM, Type Assertions, and More!
84. A Simple Project Setup
85. Working With The DOM
86. The Lib Compiler Option
87. TypeScript's Non-Null Assertion Operator
88. Type Assertions
89. Type Assertions With the DOM
90. Working With Events
91. Building The Todo List
92. Adding in an Interface
93. Connecting to LocalStorage
94. Todo List Finishing Touches
95. Classes
96. Classes Setup
97. The Class Keyword
98. Constructors
99. Class Fields
100. Private Fields
101. Getters
102. Setters
103. Static Properties & Methods
104. Extending Classes
105. The Dreaded Super()
106. TypeScript Classes
107. Annotating Classes In TypeScript
108. Class Fields In TypeScript
109. readonly Class Properties
110. The public Modifier
111. The private Modifier
112. Parameter Properties Shorthand
113. Getters and Setters
114. The Protected Modifier
115. Classes and Interfaces
116. Creating Abstract Classes
117. Generics
118. Introducing Generics
119. Another Example Of A Built-In Generic
120. Writing Our First Generic
121. Writing Another Generic Function
122. Inferred Generic Type Parameters
123. Generics, Arrow Functions, & TSX Files
124. Generics With Multiple Types
125. Adding Type Constraints
126. Default Type Parameters
127. Writing Generic Classes
128. Type Narrowing
129. Typeof Guards
130. Truthiness Guards
131. Equality Narrowing
132. Narrowing With The In Operator
133. Instanceof Narrowing
134. Working With Type Predicates
135. Discriminated Unions
136. Exhaustiveness Checks With Never
137. Working With Type Declarations
138. Introducing Type Declarations
139. Using 3rd Party Libraries: Axios
140. Working With Axios Types
141. Installing Types Separately
142. Modules
143. A Note On Namespaces
144. Working Without Modules
145. Using TypeScript Modules
146. Changing Compilation Module System
147. Import/Export Syntax In Depth
148. Importing Types
149. Webpack & TypeScript
150. What's The Point Of Webpack?
151. Setting Up a Project
152. Installing Webpack Dependencies
153. Basic Webpack Config
154. Adding Source Maps
155. IMPORTANT NOTE: Fixing the Missing devServer Config
156. Webpack Dev Server
157. Production Configuration
158. React & TypeScript
159. React & TypeScript Introduction
160. Create React App With TypeScript
161. Our First Component
162. A Note on React.FC
163. Props With TypeScript
164. Creating Our ShoppingList Component
165. useState With TypeScript
166. Creating Our ShoppingItem Form
167. useRef With TypeScript
168. Updating The State
169. Finishing Touches
170. React + TypeScript Wrapup

TypeScript is an amazing technology that helps developers write better code with less errors - simply because it let's you catch & fix type-related errors immediately whilst writing the code (instead of when testing the application).

But using TypeScript with React can sometimes be tricky. Especially when building more complex, dynamic components, defining the right types can be challenging.

That's why I built this course!

This course will teach you how to use TypeScript with React - and, of course, the course will introduce you to all the core concepts & patterns you need to work with components, state, side effects & more in a type-safe way!

This course will:

• Teach you WHY using TypeScript in your React projects might be a good idea

• Introduce you to the key TypeScript concepts you'll need - when working with React & in general

• Get you started with using TypeScript with React - for components, state & more

• Explore more advanced, complex patterns & examples

• Help you with building dynamic or even polymorphic components in a type-safe way

• Teach you how to use TypeScript with React's Context API

• Explore how you can enhance code used with useReducer() with help of TypeScript

• Cover data fetching & useEffect() with TypeScript

• Use the popular Redux library in a type-safe way

• Build or improve multiple demo projects so that can apply your knowledge

By the end of the course, you'll be able to use TypeScript in your own (future) React projects and write better, more type-safe code.

Course prerequisites:

• NO prior TypeScript knowledge is required - though basic knowledge will help (but the course includes an introduction module)

• Basic React knowledge (components, JSX, state) IS required - more advanced concepts will be explained though

1. Introduction
2. Welcome To The Course!
3. Why React & TypeScript?
4. About The Course & Course Content
5. How To Get The Most Out Of The Course
6. Learning Community & Course Resources
7. Creating & Using React + TypeScript Projects
8. Course Setup
9. TypeScript Basics & Core Concepts
10. Module Introduction
11. TypeScript Setup & Using TypeScript
12. Working with Types: Type Inference & Explicit Type Annotations
13. Basic Primitive Types
14. Invoking The TypeScript Compiler
15. Combining Types Union Types (Alternative Types)
16. Working with Object Types
17. Working with Array Types
18. Adding Types to Functions - Parameter & Return Value Types
19. Defining Function Types
20. Creating Custom Types / Type Aliases
21. Defining Object Types with Interfaces
22. Interfaces vs Custom Types
23. Merging Types
24. Being Specific With Literal Types
25. Adding Type Guards
26. Type Guards & Type Narrowing - A Closer Look
27. Making Sense Of Generic Types
28. Summary
29. Using TypeScript with React - Essentials
30. Module Introduction
31. Creating a React + TypeScript Project
32. Understanding the Role of tsconfig.json
33. Building a First Component & Facing a Missing Type
34. Defining Component Props Types
35. Storing Props Types as a Custom Type or Interface
36. Defining a Type for Props with "children"
37. Component Props & The Special "key" Prop
38. Another Way Of Typing Components
39. Exercise: Creating a Header Component
40. Using useState() and TypeScript
41. Working with State & Outputting State-based Values
42. Another Exercise & Reusing Types Across Files
43. Passing Functions as Values - In A Type-Safe Way
44. Handling & Typing Events
45. Working with Generic Event Types
46. Using useRef() with TypeScript
47. Handling User Input In A Type-Safe Way
48. Summary
49. Advanced Component Types - Dynamic Components, Polymorphic Components & More
50. Module Introduction
51. Building a More Dynamic & Flexible Component
52. Problem: Flexible Components With Required Prop Combinations
53. Solution: Building Components with Discriminated Unions
54. Onwards To A New Project
55. Building a Basic Wrapper Component
56. Building Better Wrapper Components with ComponentPropsWithoutRef
57. Building a Wrapper Component That Renders Different Elements
58. Working with Type Predicates & Facing TypeScript Limitations
59. Building a Basic Polymorphic Component
60. Building a Better Polymorphic Component with Generics
61. Examples: More Component Ideas
62. Using forwardRef with TypeScript
63. Building Another Wrapper Component (Custom Form Component)
64. Sharing Logic with "unknown" & Type Casting
65. Exposing Component APIs with useImperativeHandle (with TypeScript)
66. Alternative: Avoiding Type Casting with "as"
67. Summary
68. Advanced Type-Safe State with Context API & useReducer()
69. Module Introduction
70. The Starting Project
71. Creating a Context & Fitting Types
72. Creating a Type-Safe Provider Component
73. Accessing Context Type-Safe With A Custom Hook
74. Getting Started with useReducer() & TypeScript
75. A Basic Reducer Function & A Basic Action Type
76. Changing State via the Reducer Function
77. Using Better Action Types
78. Wiring Everything Up & Finishing the App
79. Side Effects, useEffect() & Data Fetching with TypeScript
80. Module Introduction
81. Creating a First Side Effect
82. Using useEffect() with TypeScript
83. Managing An Interval With Refs & The Effect Cleanup Function
84. useEffect() & Its Dependencies
85. A Small Bug & Its Solution
86. Onwards to Data Fetching!
87. Building a Utility "get" Function with TypeScript
88. Fetching & Transforming Data
89. Alternative: Using the "zod" Library for Response Data Validation
90. Alternative: A Generic "get" Function
91. Handling Loading & Error States
92. Using Redux with TypeScript
93. Module Introduction
94. The Starting Project
95. Redux Setup
96. Creating a Redux Store & A First Slice
97. Setting a State Type
98. A First Reducer & Controlling the Action Payload Type
99. Adding Logic To The Reducer
100. Providing the Redux Store
101. Dispatching Actions & Adjusting the useDispatch Hook
102. Creating a Type-Safe useSelector Hook
103. Selecting & Transforming Redux Store Data
104. Finishing Touches & Summary
105. Practice Project: A "Book a Session" Management Application
106. Your Task
107. Your Task - Details
108. Hints
109. An Example Solution
110. Bonus Content
111. Bonus Lecture

Learn what TypeScript is, why it really is a powerful addition to JavaScript, what its features are and how to use it! Learn why TypeScript is amazing, how it improves your JavaScript code and how it helps you avoid nasty bugs and errors!

This course takes you from the very basics and its most important feature (types!) to the point where you're able to use TypeScript in any of your projects. ReactJS projects included!

As TypeScript is developed by Microsoft and strongly advertised and used by Angular 2+ (Google) and other popular libraries, it's here to stay. Indeed, TypeScript is one of the most popular web development languages you can learn these days!

Gain an edge today and be amongst the first to really understand TypeScript!

Learn how you can use TypeScript to bring modern JS features like destructuring, arrow functions or classes to any environment and codebase - even if it does not support those features yet!  Understand which types you may use and how you can build your own types. Learn how to write better code with types and with the many features offered by TypeScript!

But, in this course, we'll not stop after the basics! You will also learn about more advanced features (like decorators) and also how to set up workflows with  TypeScript. This includes a TypeScript-only workflow as well as a webpack workflow.

You'll also learn that you're not limited to Angular or plain JavaScript/ TypeScript projects. Instead, a complete module covers how you may use TypeScript with ReactJS and improve your React code with TypeScript as well.

Practice what you learn!

Watching videos is a great way to learn. And to a lot of students, it's the best way. If you also want to practice the things you learn, this course offers you more than that though. Because this course comes with plenty of exercises (and solutions, of course) in addition to all the high-quality learning videos.

So much Content!

I'm not a fan of these courses which teach you the basics and then leave you alone. Instead, in this course you'll get insights into:

• Types and how to use them

• How the TypeScript compiler works (and how you may configure it)

• ES6 features with TypeScript

• Classes in TypeScript

• Namespaces and modules

• Interfaces

• Generics

• Decorators

• How to integrate Third-Party JavaScript libraries into your TypeScript projects

• How to set up a TypeScript project with webpack

• Or how to set up a plain-TypeScript workflow

• How to use TypeScript together with ReactJS

• How to use TypeScript together with Node/ Express

• Real projects and use-cases!

• And so much more!

1. Getting Started
2. Welcome to the Course!
3. What Is TypeScript & Why Should You Use It?
4. Join Our Learning Community
5. Installing & Using TypeScript
6. TypeScript Advantages - Overview
7. Course Outline
8. How To Get The Most Out Of The Course
9. Setting Up A Code Editor / IDE
10. Course Setup
11. The Course Project Setup
12. TypeScript Basics & Basic Types
13. Module Introduction
14. Using Types
15. TypeScript Types vs JavaScript Types
16. Important: Type Casing
17. Working with Numbers, Strings & Booleans
18. Type Assignment & Type Inference
19. Understanding Types
20. Object Types
21. Nested Objects & Types
22. Arrays Types
23. Working with Tuples
24. Working with Enums
25. The "any" Type
26. Union Types
27. Literal Types
28. Type Aliases / Custom Types
29. Type Aliases & Object Types
30. Core Types & Concepts
31. Function Return Types & "void"
32. Functions as Types
33. Function Types & Callbacks
34. Functions & Types
35. The "unknown" Type
36. The "never" Type
37. Wrap Up
38. Useful Resources & Links
39. The TypeScript Compiler (and its Configuration)
40. Module Introduction
41. Using "Watch Mode"
42. Compiling the Entire Project / Multiple Files
43. Including & Excluding Files
44. Setting a Compilation Target
45. Understanding TypeScript Core Libs
46. More Configuration & Compilation Options
47. Working with Source Maps
48. rootDir and outDir
49. Stop Emitting Files on Compilation Errors
50. Strict Compilation
51. Code Quality Options
52. Debugging with Visual Studio Code
53. Wrap Up
54. Useful Resources & Links
55. Next-generation JavaScript & TypeScript
56. Module Introduction
57. "let" and "const"
58. Arrow Functions
59. Default Function Parameters
60. The Spread Operator (...)
61. Rest Parameters
62. Array & Object Destructuring
63. How Code Gets Compiled & Wrap Up
64. Useful Resources & Links
65. Classes & Interfaces
66. Module Introduction
67. What are Classes?
68. Creating a First Class
69. Compiling to JavaScript
70. Constructor Functions & The "this" Keyword
71. "private" and "public" Access Modifiers
72. Shorthand Initialization
73. "readonly" Properties
74. Class Basics
75. Inheritance
76. Overriding Properties & The "protected" Modifier
77. Getters & Setters
78. Static Methods & Properties
79. Abstract Classes
80. Singletons & Private Constructors
81. Classes - A Summary
82. Classes
83. A First Interface
84. Using Interfaces with Classes
85. Why Interfaces?
86. Readonly Interface Properties
87. Extending Interfaces
88. Interfaces as Function Types
89. Optional Parameters & Properties
90. Compiling Interfaces to JavaScript
91. Interfaces
92. Wrap Up
93. Useful Resources & Links
94. Advanced Types
95. Module Introduction
96. Intersection Types
97. More on Type Guards
98. Discriminated Unions
99. Type Casting
100. Index Properties
101. Function Overloads
102. Optional Chaining
103. Nullish Coalescing
104. Advanced Types
105. Wrap Up
106. Useful Resources & Links
107. Generics
108. Module Introduction
109. Built-in Generics & What are Generics?
110. Creating a Generic Function
111. Working with Constraints
112. Another Generic Function
113. The "keyof" Constraint
114. Generic Classes
115. A First Summary
116. Generic Utility Types
117. Generic Types vs Union Types
118. Generics
119. Useful Resources & Links
120. Decorators
121. Module Introduction
122. A First Class Decorator
123. Working with Decorator Factories
124. Building More Useful Decorators
125. Adding Multiple Decorators
126. Diving into Property Decorators
127. Accessor & Parameter Decorators
128. When Do Decorators Execute?
129. Returning (and changing) a Class in a Class Decorator
130. Other Decorator Return Types
131. Example: Creating an "Autobind" Decorator
132. Validation with Decorators - First Steps
133. Validation with Decorators - Finished
134. Fixing a Validator Bug
135. Wrap Up
136. Useful Resources & Links
137. Practice Time! Let's build a Drag & Drop Project
138. Module Introduction
139. Getting Started
140. DOM Element Selection & OOP Rendering
141. Interacting with DOM Elements
142. Creating & Using an "Autobind" Decorator
143. Fetching User Input
144. Creating a Re-Usable Validation Functionality
145. Rendering Project Lists
146. Managing Application State with Singletons
147. More Classes & Custom Types
148. Filtering Projects with Enums
149. Adding Inheritance & Generics
150. Rendering Project Items with a Class
151. Using a Getter
152. Utilizing Interfaces to Implement Drag & Drop
153. Drag Events & Reflecting the Current State in the UI
154. Adding a Droppable Area
155. Finishing Drag & Drop
156. Wrap Up
157. Useful Resources & Links
158. Modules & Namespaces
159. Module Introduction
160. Writing Module Code - Your Options
161. Working with Namespaces
162. Organizing Files & Folders
163. A Problem with Namespace Imports
164. Important: Use Chrome or Firefox
165. Using ES Modules
166. Understanding various Import & Export Syntaxes
167. How Does Code In Modules Execute?
168. Wrap Up
169. Useful Resources & Links
170. Using Webpack with TypeScript
171. Module Introduction
172. What is Webpack & Why do we need it?
173. Installing Webpack & Important Dependencies
174. Adding Entry & Output Configuration
175. Adding TypeScript Support with the ts-loader Package
176. Adjust Webpack Config
177. Finishing the Setup & Adding webpack-dev-server
178. Adding a Production Workflow
179. Wrap Up
180. Useful Resources & Links
181. 3rd Party Libraries & TypeScript
182. Module Introduction
183. Using JavaScript (!) Libraries with TypeScript
184. Using "declare" as a "Last Resort"
185. No Types Needed: class-transformer
186. TypeScript-embracing: class-validator
187. Wrap Up
188. Useful Resources & Links
189. Time to Practice! Let's build a "Select & Share a Place" App (incl. Google Maps)
190. Module Introduction
191. Project Setup
192. Getting User Input
193. Setting Up a Google API Key
194. Using Axios to Fetch Coordinates for an Entered Address
195. Rendering a Map with Google Maps (incl. Types!)
196. Working with Maps without a Credit Card
197. Useful Resources & Links
198. React.js & TypeScript
199. Module Introduction
200. Setting Up a React + TypeScript Project

Composition vs Inheritance? You'll understand it.  Build your own web framework? You'll do it.  Typescript with React/Redux?  It's here!

--------------------

This is the best course online for mastering Typescript.

Every other course online teaches you the basic syntax and features of Typescript, but only this course will show you how to apply Typescript on real projects, instructing you how to build large, successful projects through example.

Typescript is a 'super-set' of Javascript.  That means that if you already know Javascript, you are ready to take this course.  Typescript adds in several important features to Javascript, including a type system.  This type system is designed to help you catch errors during development, rather than when you are running your code.  That means you'll be twice as productive by catching bugs earlier in development.  But besides the type system, Typescript also provides several tools for structuring large codebases and writing truly reusable code.

Mastering Typescript by reading the documentation alone is challenging.  Although you might know what a 'typed array' or an 'interface' is, the documentation (and other courses!) don't show you where to use this features, or how to use them effectively.  The goal of this course is to help you understand why each feature of Typescript exists, and exactly where to use them.

Top companies are hungry for Typescript developers.  Some of the largest web apps today are being built with Typescript.  Employers are scrambling to find engineers who are fluent with this cutting edge system.  Solid knowledge of Typescript will make you far more employable, by giving you a unique skill that few other engineers possess.

Planning on building your own apps?  Using Typescript will help you structure your project correctly from day one, ensuring that you won't be crushed under technical debt at some critical stage of your company.  In this course, you'll learn how to write reusable code, with a tremendous emphasis on leveraging classes and interfaces to make swappable 'widgets'.  You will be able to reconfigure your apps on the fly to build wildly different features with only a minimum amount of effort

Learn from someone who has worked on one of the largest Typescript projects around. On professional projects of my own, I have developed plugins for an open-source, browser-based code editor called Theia.  The Theia project is absolutely gargantuan in scale, encompassing hundreds of thousands of lines of code, all written in Typescript.  This project works only thanks to the power of Typescript.

But don't just take my word for it - check out the reviews for this course! You'll see that other engineers, just like yourself, have had great success and acquired a new understanding of how to build scalable web applications.

--------------------

There is just too much content in this course to summarize in a few short words, but here is a partial listing of the different skills you'll master:

• Understand why Composition vs Inheritance is the most mis-understood topic in the Javascript community

• Master the fundamental features of Typescript by working on real world projects

• We'll build a custom front-end framework from scratch that you can use in place of React or Angular on your own personal projects

• Comprehend the complex interplay between classes and interfaces, and why these two pieces of Typescript enable you to build incredibly reusable code

• Dive deeper into Typescript with decorators, which we'll use to build a custom integration between Typescript and Express

• Structure your React and Redux applications more confidently by understanding how to couple them with Typescript

• Skip the documentation for third party libraries by fluently reading type definition files

• Learn just how smart Typescript is by experiencing how deeply it analyzes your code for errors

  
  

I learned Typescript years ago by hard trial-and-error.  Now you can learn at 5x the speed I did.  This is the course that I wish I had when I first got started with Typescript.

1. Getting Started with Typescript
2. How to Get Help
3. Join Our Community!
4. Course Resources
5. Typescript Overview
6. Environment Setup
7. Important Axios and TypeScript Version Information
8. A First App
9. Executing Typescript Code
10. One Quick Change
11. Catching Errors with Typescript
12. Catching More Errors!
13. What is a Type System?
14. Do Not Skip - Course Overview
15. Types
16. More on Types
17. Examples of Types
18. Where Do We Use Types?
19. Types
20. Type Annotations in Action
21. Type Annotations and Inference
22. Annotations with Variables
23. Object Literal Annotations
24. Annotations Around Functions
25. Understanding Inference
26. The 'Any' Type
27. Fixing the 'Any' Type
28. Delayed Initialization
29. When Inference Doesn't Work
30. Annotations With Functions and Objects
31. More on Annotations Around Functions
32. Inference Around Functions
33. Annotations for Anonymous Functions
34. Void and Never
35. Destructuring with Annotations
36. Annotations Around Objects
37. Mastering Typed Arrays
38. Arrays in Typescript
39. Why Typed Arrays?
40. Multiple Types in Arrays
41. When to Use Typed Arrays
42. Tuples in Typescript
43. Tuples in Typescript
44. Tuples in Action
45. Why Tuples?
46. The All-Important Interface
47. Interfaces
48. Long Type Annotations
49. Fixing Long Annotations with Interfaces
50. Syntax Around Interfaces
51. Functions in Interfaces
52. Code Reuse with Interfaces
53. General Plan with Interfaces
54. Interfaces
55. Building Functionality with Classes
56. Classes
57. Basic Inheritance
58. Instance Method Modifiers
59. Fields in Classes
60. Fields with Inheritance
61. Where to Use Classes
62. Design Patterns with Typescript
63. Updated Parcel Instructions
64. App Overview
65. Bundling with Parcel
66. Project Structure
67. IMPORTANT Info About Faker Installation
68. Generating Random Data
69. Type Definition Files
70. Using Type Definition Files
71. Export Statements in Typescript
72. Defining a Company
73. Note on Generating an API Key
74. Adding Google Maps Support
75. Required Update for New @types Library
76. Google Maps Integration
77. Exploring Type Definition Files
78. Hiding Functionality
79. Why Use Private Modifiers? Here's Why
80. Adding Markers
81. Duplicate Code
82. One Possible Solution
83. Restricting Access with Interfaces
84. Implicit Type Checks
85. Showing Popup Windows
86. Updating Interface Definitions
87. Optional Implements Clauses
88. App Wrapup
89. More on Design Patterns
90. App Overview
91. Configuring the TS Compiler
92. Concurrent Compilation and Execution
93. A Simple Sorting Algorithm
94. Sorter Scaffolding
95. Sorting Implementation
96. Two Huge Issues
97. Typescript is Really Smart
98. Type Guards
99. Why is This Bad?
100. Extracting Key Logic
101. Separating Swapping and Comparison
102. The Big Reveal
103. Interface Definition
104. Sorting Arbitrary Collections
105. Linked List Implementation
106. Completed Linked List Code
107. Just...One...More...Fix...
108. Integrating the Sort Method
109. Issues with Inheritance
110. Abstract Classes
111. Why Use Abstract Classes?
112. Solving All Issues with Abstract Classes
113. Interfaces vs Abstract Classes
114. Reusable Code
115. Project Overview
116. Project Setup
117. CSV Data
118. Type Definition Files - Again!
119. Reading CSV Files
120. Running an Analysis
121. Losing Dataset Context
122. Using Enums
123. When to Use Enums
124. Extracting CSV Reading
125. Data Types
126. Converting Date Strings to Dates
127. Converting Row Values
128. Type Assertions
129. Describing a Row with a Tuple
130. Not Done with FileReader Yet!
131. Understanding Refactor #1
132. Creating Abstract Classes
133. Variable Types with Generics
134. Applying a Type to a Generic Class
135. Alternate Refactor
136. Interface-Based Approach
137. Extracting Match References - Again!
138. Transforming Data
139. Updating Reader References
140. Inheritance vs Composition
141. More on Inheritance vs Composition
142. A Huge Misconception Around Composition
143. Goal Moving Forward
144. A Composition-Based Approach
145. Implementing an Analyzer Class
146. Building the Reporter
147. Putting It All Together
148. Generating HTML Reports
149. One Last Thing!
150. Oops, My Bad
151. App Wrapup
152. Advanced Generics
153. More on Generics
154. Type Inference with Generics
155. Function Generics
156. Generic Constraints
157. Let's Build a Web Framework
158. App Overview
159. Reminder on Using Parcel with npx
160. Parcel Setup
161. Framework Structure
162. Designing the User
163. Retrieving User Properties
164. Optional Interface Properties
165. An Eventing System
166. Listener Support
167. Storing Event Listeners
168. Dynamic Array Creation
169. Triggering Event Callbacks
170. Small Update for JSON server and Parcel Start Script
171. Adding JSON Server
172. Understanding REST Conventions
173. Adding Fetch Functionality
174. Successfully Fetching Model Data
175. Saving User Data
176. Refactoring with Composition
177. Re-Integrating Eventing
178. Composition with Nested Objects
179. A More Complicated Extraction
180. Options for Adapting Sync
181. Refactoring Sync
182. Generic Constraints Around Sync
183. Connecting Sync Back to User
184. Optional Properties
185. No overload matches this call - this.data
186. Extracting an Attributes Class
187. The Get Method's Shortcoming
188. Two Important Rules
189. An Advanced Generic Constraint
190. Re-Integrating Attributes
191. Composition is Delegation
192. Reminder on Accessors
193. Passthrough Methods
194. A Context Issue
195. Setting Data While Triggering
196. Fetching User Data
197. Saving Data
198. Composition vs Inheritance...Again!
199. Extracting a Model Class
200. Extending the User

Welcome to this one-of-a-kind course specifically designed to transform your TypeScript programming skills by diving deep into the world of Gang Of Four Design Patterns, SOLID Design principles, and Object-Oriented Programming (OOP) concepts. Are you an aspiring or intermediate programmer looking to level up your game? Or are you an advanced programmer and need a refresher on the Gang Of Four Design Patterns and SOLID Design Principles? Do you have a grasp of TypeScript and now want to focus on architectural excellence and code reusability? If so, you've come to the right place!

This course isn't just another tutorial; it's your passport to becoming an advanced TypeScript developer. Throughout more than 140 high-definition videos, totaling over 10 hours of content, we'll delve into the nuances of effective software design and programming. We go beyond theory by providing practical, hands-on coding exercises and quizzes that reinforce your learning and provide the skills you need for the real world. With this course, you don't just learn; you practice, implement, and master the art of writing clean, efficient, and robust TypeScript code using the SOLID Design Principles and Gang Of For Design Patterns using TypeScript.

Uniquely, this course covers all three key areas you need for excellence in modern software development:

1. Design Patterns: Master the Gang Of Four Design Patterns like Singleton, Builder,  Strategy, and many more to solve specific problems efficiently.

2. SOLID Design Principles: Understand and implement the SOLID principles that serve as the foundation for writing maintainable and scalable code.

3. Object-Oriented Programming Concepts: Learn and apply the four pillars of OOP—Inheritance, Encapsulation, Polymorphism, and Abstraction—in TypeScript, enabling you to write code that is both functional and elegant.

Design Patterns You Will Learn In This Course:

• Creational Design Patterns

  • Factory

  • Abstract Factory

  • Builder

  • Prototype

  • Singleton

• Structural Design Patterns

  • Decorator

  • Adapter

  • Facade

  • Bridge

  • Composite

• Behavioral Design Patterns

  • Command

  • Chain of Responsibility

  • Observer Pattern

  • Interpreter

  • Iterator

  • State

  • Strategy

  • Template

By the end of this course, you'll not only have a deep understanding of Software Design Patterns, SOLID principles, and OOP in TypeScript but also be equipped with the practical skills to apply these concepts in your future projects. Whether you are developing enterprise-level applications or working on freelance gigs, the skills you acquire here will make you stand out in the TypeScript development community.

1. Intro To Design Patterns
2. Welcome
3. How To Make The Most Out Of This Course
4. Note About Resource
5. Intro To Design Patterns and Their History
6. Why We Need Design Patterns
7. Cautions and Considerations
8. Classification Of Design Patterns
9. Intro To UML
10. Setup Development Environment
11. OOP In TypeScript
12. What is OOP
13. OOP Lingo
14. Abstraction
15. Abstraction Implementation
16. Abstraction Real World Use case
17. Abstraction Advantages
18. Abstraction Quiz
19. Encapsulation
20. Encapsulation Implementation
21. Encapsulation Advantages
22. Encapsulation Quiz
23. Polymorphism (Subtype)
24. Polymorphism Use Cases
25. Polymorphism Advantages
26. Polymorphism Quiz
27. Inheritance
28. Inheritance Implementation
29. Inheritance Advantages
30. Inheritance Quiz
31. SOLID Design Principles
32. SOLID Design Principles Introduction
33. Single Responsibility Principle (SRP) Intro
34. Real World Application Of SRP
35. Advantages Single Responsibility Principle
36. Single Responsibility Principle Quiz
37. Open Closed Principle (OCP) Intro
38. Real World Application Open Closed Principle
39. Advantages Of Open Closed Principle
40. Open closed Principle Quiz
41. Liskov Substitution Principle (LSP)
42. Real World Application LSP
43. Advantages Of The Liskov Substitution Principle
44. Liskov Substitution Principle Quiz
45. Interface Segregation Principle (ISP)
46. Real World Application of ISP
47. Advantages Of Interface Segregation Principle
48. Interface Segregation Principle Quiz
49. Dependency Inversion Principle (DIP)
50. Implementation Of Dependency Inversion Principle (DIP)
51. Advantages Of Dependency Inversion Principle
52. Dependency Inversion Principle Quiz
53. Creational Design Patterns
54. Introduction To Creational Design Patterns
55. Singleton Pattern
56. When To Use Singleton Pattern
57. Singleton Real World Implementation
58. Singleton Advantages
59. Caveats or Criticism Of Singleton Pattern
60. Singleton Use Cases
61. Singleton Design Pattern Quiz
62. Prototype Pattern
63. When To Use Prototype Pattern
64. Prototype Real World Implementation
65. Prototype Advantages
66. Caveats or Criticism Of Prototype Pattern
67. Prototype Use Cases
68. Prototype Pattern Quiz
69. Builder Pattern
70. When To Use Builder Pattern
71. Builder Real World Implementation
72. Builder Pattern Advantages
73. Caveats or Criticism Of Builder Pattern
74. Builder Use Cases
75. Builder Pattern Quiz
76. Factory Pattern
77. When To Use Factory Pattern
78. Factory Real World Implementation
79. Factory Pattern Advantages
80. Caveats or Criticism Of Factory Pattern
81. Factory Pattern Use Cases
82. Factory Pattern Quiz
83. Abstract Factory Pattern
84. When To Use Abstract Factory Pattern
85. Abstract Factory Real World Implementation
86. Abstract Factory Advantages
87. Caveats or Criticism Of Abstract Factory Pattern
88. Abstract Factory Pattern Use Cases
89. Abstract Factory Pattern Quiz
90. Structural Design Patterns
91. Introduction To Structural Design Patterns
92. Facade Pattern
93. When To Use Facade Pattern
94. Facade Real World Implementation
95. Facade Pattern Advantages
96. Caveats or Criticism Of Facade Pattern
97. Facade Pattern Use Cases
98. Facade Pattern Quiz
99. Bridge Pattern
100. When To Use Bridge Pattern
101. Bridge Real World Implementation
102. Bridge Pattern Advantages
103. Caveats or Criticism Of Bridge Pattern
104. Bridge Pattern Use Cases
105. Bridge Pattern Quiz
106. Composite Pattern
107. When To Use Composite Pattern
108. Composite Real World Implementation
109. Composite Pattern Advantages
110. Caveats or Criticism Of Composite Pattern
111. Composite Pattern Use Cases
112. Composite Pattern Quiz
113. Decorator Pattern
114. When To Use Decorator Pattern
115. Decorator Real World Implementation
116. Decorator Pattern Advantages
117. Caveats or Criticism Of Decorator Pattern
118. Decorator Pattern Use Cases
119. Decorator Pattern Quiz
120. Adapter Pattern
121. When To Use Adapter Pattern
122. Adapter Real World Implementation
123. Adapter Pattern Advantages
124. Caveats or Criticism Of Adapter Pattern
125. Adapter Pattern Use Cases
126. Adapter Pattern Quiz
127. Behavioural Design Patterns
128. Introduction To Behavioural Design Patterns
129. Observer Pattern
130. When To Use Observer Pattern
131. Observer Real World Implementation
132. Observer Pattern Advantages
133. Caveats Or Criticism Of Observer Pattern
134. Observer Patterns Use Cases
135. Observer Pattern Quiz
136. Iterator Pattern
137. When To Use Iterator Pattern
138. Iterator Real World Implementation
139. Iterator Pattern Advantages
140. Caveats Or Criticism Of Iterator Pattern
141. Iterator Patterns Use Cases
142. Iterator Pattern Quiz
143. Strategy Design Pattern
144. When To Use The Strategy Pattern
145. Strategy Real World Implementation
146. Strategy Pattern Advantages
147. Caveats Or Criticism Of The Strategy Pattern
148. Strategy Pattern Use Cases
149. Strategy Pattern Quiz
150. Template Method Pattern
151. When To Use The Template Pattern
152. Template Pattern Real World Implementation
153. Template Pattern Advantages
154. Caveats Or Criticism Of The Template Pattern
155. Template Pattern Use Cases
156. Template Method Pattern Quiz
157. Command Design Pattern
158. When To Use The Command Pattern
159. Command Pattern Real World Implementation
160. Command Pattern Advantages
161. Caveats Or Criticism Of The Command Pattern
162. Command Pattern Use Cases
163. Command Pattern Quiz
164. State Design Pattern
165. When To Use The State Design Pattern
166. State Design Pattern Real World Implementation
167. State Design Pattern Advantages
168. Caveats Or Criticism Of The State Design Pattern
169. State Design Pattern Use Cases
170. State Design Pattern Quiz
171. Chain of Responsibility Pattern
172. When To Use Chain of Responsibility
173. Chain of Responsibility Real World Implementation
174. Chain of Responsibility Advantages
175. Caveats Or Criticism Of The Chain of Responsibility
176. Chain of Responsibility Use Cases
177. Chain Of Responsibility Quiz