Typescript: The Complete Developer’s Guide

Typescript: The Complete Developer’s Guide

Check it out: Typescript: The Complete Developer’s Guide

What you’ll learn

Master design patterns for building large applications
Integrate Typescript into React/Redux or Express projects
Understand Composition vs Inheritance, and when to use each
Write reusable code powered by classes and interfaces
Assemble reusable boilerplates for your own Typescript projectsCourse content
Expand all 278 lectures24:35:07
–Getting Started with Typescript
41:20
How to Get Help
Preview
01:04
Typescript Overview
Preview
06:19
Environment Setup
Preview
07:59
A First App
04:43
Executing Typescript Code
05:03
One Quick Change
03:35
Catching Errors with Typescript
07:22
Catching More Errors!
05:15
–What is a Type System?
20:18
Do Not Skip – Course Overview
03:36
Types
05:12
More on Types
05:53
Examples of Types
04:48
Where Do We Use Types?
00:49
Types
3 questions
–Type Annotations in Action
40:53
Type Annotations and Inference
02:03
Annotations with Variables
04:53
Object Literal Annotations
06:53
Annotations Around Functions
05:55
Understanding Inference
03:51
The ‘Any’ Type
07:47
Fixing the ‘Any’ Type
01:49
Delayed Initialization
03:05
When Inference Doesn’t Work
04:37
–Annotations With Functions and Objects
26:15
More on Annotations Around Functions
04:56
Inference Around Functions
06:08
Annotations for Anonymous Functions
01:42
Void and Never
02:49
Destructuring with Annotations
03:35
Annotations Around Objects
07:05
–Mastering Typed Arrays
13:26
Arrays in Typescript
05:05
Why Typed Arrays?
04:30
Multiple Types in Arrays
02:57
When to Use Typed Arrays
00:54
–Tuples in Typescript
12:52
Tuples in Typescript
04:04
Tuples in Action
05:28
Why Tuples?
03:20
–The All-Important Interface
26:28
Interfaces
01:26
Long Type Annotations
04:42
Fixing Long Annotations with Interfaces
04:36
Syntax Around Interfaces
03:31
Functions in Interfaces
04:46
Code Reuse with Interfaces
04:15
General Plan with Interfaces
03:12
Interfaces
5 questions
–Building Functionality with Classes
25:16
Classes
03:47
Basic Inheritance
03:03
Instance Method Modifiers
06:41
Fields in Classes
06:18
Fields with Inheritance
04:18
Where to Use Classes
01:09
–Design Patterns with Typescript
02:13:35
App Overview
02:45
Bundling with Parcel
04:55
Project Structure
03:19
Generating Random Data
05:29
Type Definition Files
05:17
Using Type Definition Files
06:20
Export Statements inTypescript
05:06
Defining a Company
04:43
Note on Generating an API Key
00:24
Adding Google Maps Support
07:38
Google Maps Integration
04:06
Exploring Type Definition Files
12:46
Hiding Functionality
06:28
Why Use Private Modifiers? Here’s Why
08:25
Adding Markers
09:18
Duplicate Code
02:45
One Possible Solution
06:38
Restricting Access with Interfaces
05:35
Implicit Type Checks
03:26
Showing Popup Windows
06:47
Updating Interface Definitions
07:11
Optional Implements Clauses
06:06
App Wrapup
08:08
–More on Design Patterns
02:34:35
App Overview01:34
Configuring the TS Compiler
07:40
Concurrent Compilation and Execution
05:05
A Simple Sorting Algorithm
04:47
Sorter Scaffolding
03:10
Sorting Implementation
05:17
Two Huge Issues
07:37
Typescript is Really Smart
09:34
Type Guards
09:13
Why is This Bad?
02:22
Extracting Key Logic
07:29
Separating Swapping and Comparison
13:58
The Big Reveal
04:38
Interface Definition
04:48
Sorting Arbitrary Collections
11:08
Linked List Implementation
24:15
Completed Linked List Code
00:01
Just…One…More…Fix…
04:03
Integrating the Sort Method
02:44
Issues with Inheritance
06:54
Abstract Classes
06:25
Why Use Abstract Classes?
04:30
Solving All Issues with Abstract Classes
04:00
Interfaces vs Abstract Classes
03:23
8 more sections
Requirements

Basic knowledge of ES2015 Javascript

Description

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.
Who this course is for:

Any Javascript developer looking to understand how to structure large codebases