Mastering TypeScript

Explore TypeScript in depth with detailed examples and put it all into practice by building a project

TypeScript gives the developer instant feedback on the code they are writing in order to catch mistakes earlier in the development process. Since it is transpiled to JavaScript, developers can take advantage of future JavaScript language features today.

Mastering TypeScript will take you on a journey from understanding and interacting with the type system to working efficiently with more advanced features of the language.

We’ll start by introducing a simple client/server application. Then use the application to demonstrate key components of the TypeScript language.

Once the sample application is set up, we’ll look in detail at TypeScript’s type system. Then we take a look at more advanced language features, learn to deal with JavaScript libraries, and finally use TypeScript to utilize static typing between parts of an application.

Mastering TypeScript will help you write better TypeScript code and gain a deeper understanding of the language.

About The Author
David Sherret is a software developer in the healthcare industry. Within that, he leads several projects including one that supports the logistics behind specialty pharmaceuticals and maintains a patented technology for reducing health insurance fraud.

You can find him answering questions on the TypeScript tag on Stack Overflow.

What are the requirements?

• All that is expected is a working knowledge of JavaScript and basic exposure to TypeScript.

What am I going to get from this course?

• Over 41 lectures and 3 hours of content!
• Compile the sample application and analyze its overall structure.
• Understand TypeScript’s type system and how to use it more effectively.
• Broaden your knowledge on ES6 classes and how they relate to class-like JavaScript patterns.
• Familiarize yourself with JavaScript libraries in TypeScript.
• Improve your code with TypeScript language features.
• Use advanced experimental ES6 and ES7 features.
• Create static typing between a client and server in a client/server application. Bring the view code into TypeScript to have static typing.
• Interact efficiently with the type system for better and structured code.

What is the target audience?

• If you've spent time with TypeScript and know how things work on a basic level, this video course will allow you to graduate to a level of mastery.

Curriculum
Section 1: Getting Started
Lecture 1 The Course Overview 03:23
This video will offer the overview of the course.

Lecture 2 Sample Application Overview 04:13
What does the sample application look like?

Lecture 3 Compiling TypeScript in the Sample Application 04:31
We need to add TypeScript to the sample application. This video will review some of the ways of compiling Typescript, and then show you how we are going to compile the sample application in this case.

Section 2: Deploying the Type System
Lecture 4 Implicit or Explicit Types 06:53
When should implicit types be used and when should explicit types be used?

Lecture 5 Avoiding the "any" Type 03:36
The “any” type should be avoided. This video will explain why.

Lecture 6 Being Aware of Structural Typing 02:42
Not many developers know that TypeScript uses a structural type of system instead of a nominal one.

Lecture 7 Type System Troubles 04:07
What are some troubles that people experience with the type system?

Lecture 8 Compiler Options for Added Support 02:23
What compiler options can we use to make the compiler stricter?

Lecture 9 Enforcing Rules and Coding Standards 04:23
What is a linter and what benefit does it bring?

Section 3: Moving to ES6 Classes
Lecture 10 Introduction – Before Moving 03:54
This video will introduce the viewer to moving towards ES6 classes.

Lecture 11 Class-like JavaScript Patterns to TypeScript (Part 1) 05:52
How can we convert some JavaScript patterns to ES6 classes?

Lecture 12 Class-like JavaScript Patterns to TypeScript (Part 2) 04:24
How can we convert some JavaScript patterns to ES6 classes?

Lecture 13 Static Class-like Patterns in TypeScript 03:17
What do static class-like patterns look like in TypeScript?

Lecture 14 Shortening a Class with Parameter Properties 01:40
How do we reduce code written using parameter properties?

Lecture 15 When to Use Arrow Function Properties 06:01
When should we use arrow methods on a class?

Section 4: Interacting with the Type System
Lecture 16 Assert and Guard 05:24
What is type assertion and type guarding and how can we use them appropriately?

Lecture 17 Making the Most of Type Guarding 05:05
How can we use type guarding in situations where type guarding doesn't work?

Lecture 18 Multiple Function Signatures 06:04
When should we use function overloading, optional, and default parameters?

Lecture 19 Rest and Spread 02:19
What are some other features we can use with functions?

Lecture 20 Extending Built-in Types 04:00
How can we extend built-in types without modifying an object we don't own?

Lecture 21 Code Refactoring 03:21
What is code refactoring and how do we use it in TypeScript?

Section 5: Representing JavaScript Libraries
Lecture 22 Definition Files 04:35
What are definition files?

Lecture 23 Writing a Definition File 07:46
How can we write a definition file?

Lecture 24 Strong Typing JavaScript Libraries on the Run 05:24
How can we use a JavaScript library when we don’t have time to write a full definition file?

Lecture 25 Downloading and Managing Definition Files 05:43
What’s the best way to manage definition files?

Lecture 26 Included Definition Files 04:17
What are some of the definition files included by default in TypeScript?

Section 6: Language Features for Code Improvement
Lecture 27 Making the Most of let and const 05:18
What is let and const? How do they differ from 'var'?

Lecture 28 Working with Strings 06:00
What’s a better way we can work with strings in TypeScript?

Lecture 29 enums 05:21
How can we use enums to write better code?

Lecture 30 const enums Versus enums 03:23
What are const enums and how do they differ from enums?

Lecture 31 Moving to ES6 Modules 07:46
How can we use ES6 modules to write better code?

Lecture 32 Destructuring 05:12
What is destructuring and how can it help us write better code?

Section 7: Advanced ES6 and ES7 Features
Lecture 33 Introduction to Generators 06:27
What are generators? How do they work?

Lecture 34 Improving Performance and Efficiency with Generators 03:59
How do generators help improve performance and efficiency in our application?

Lecture 35 Easier Asynchronous Code with async/await 03:53
How does async and await work?

Lecture 36 Harnessing the Power of Decorators 07:36
How can decorators help us in our code? In this video, we’ll step through an example in our sample app.

Lecture 37 Advanced Decorators 03:34
How can we have a decorator with parameters?

Section 8: Bridging Statically Typed Gaps
Lecture 38 Sharing Code Across Applications 05:23
How can we share code across multiple applications?

Lecture 39 Bridging with Interfaces 05:48
What’s one way that we can help bridge the type gap?

Lecture 40 Bridging with Code Generation 03:24
How can we bridge the server/client strongly typed gap?

Lecture 41 Using TSX Files 05:11
How can we bridge the gap between our View and client-side TypeScript code?







For More Rare Movies Check out my blog!

No Mirrors Please