What you'll learn:
- Code in Github repository with downloadable ZIP files per section
- Learn the Typescript language in depth, including it's most advanced features
- Build practical real-world project in both the backend and the frontend
- Every feature covered, including: Object Oriented Programming, Generics, Decorators
- Build a Secure Node REST API with Express and TypeORM
This course covers in-depth the Typescript language and includes several practical projects. It comes with a running Github repo.
This Course in a Nutshell
One of the biggest novelties in the Javascript frontend development space in the last few years is that the use of Typescript has become almost universal.
To the point that it almost does not make sense anymore to start a new project and not use Typescript, given its huge advantages, and almost no downsides.
And this includes projects not only in Node, but also in React, Angular, and any other Javascript-based frontend framework.
Typescript is a strongly typed language that is a superset of Javascript, meaning that Javascript programs are valid Typescript programs (depending on the settings we use for the compiler), but not the other way around.
So in a nutshell, this means that you can see Typescript as a better and improved version of Javascript.
But even though superficially similar, Typescript due to its powerful type system is actually a completely different language than Javascript.
The static type system of Typescript provides many advantages as it allows us to catch many program errors at development instead of at runtime, and it enables powerful development tooling such as precise auto-completion and different types of refactoring.
But to benefit from the power of the type system, we actually don't have to add type annotations everywhere and end up with code that looks like Java or C#, and sacrifice flexibility, development speed and readability.
The type system can automatically infer the types of most variables automatically, without us having to declare them explicitly, meaning that we can essentially write type-safe Javascript-like code with minimal type annotations.
This powerful type inference is really the killer language feature that makes Typescript the preferred way of starting both a frontend and a backend project today: we get all the benefits of a static type system essentially for free, with no downsides.
Course Overview
This course is divided into multiple sections, that you can take directly depending on your previous level of familiarity with the language. So there are multiple learning paths available for you, depending on your previous experience.
The course will start with a deep dive into all the language features starting with the most basic ones but covering also in detail the most advanced features.
So if you are already familiar with some of the features you can skip ahead, and focus only on the features that you aren't aware of yet.
We will present the language features from the most elementary ones to the most advanced, and we will cover first the features that are most commonly used.
For completeness, we will also cover a lot of features that are rarely used, but we will point that out explicitly, especially if it's a feature that you are very unlikely to ever use while coding at the application level.
Besides the language features, we are going to dedicate a full section to the configuration of the Typescript compiler, and go over every option you have available.
We will make it clear when a compiler feature is rarely needed when compared with features that you will be using all the time.
We will still cover everything for completeness, but we want to give you the option to focus only on the most commonly used compiler options if that is what you prefer.
After this initial section covering all language features, we are going to cover also in detail Object-oriented programming, Generics and Decorators, each in their own section.
These 3 sections are mostly independent of the rest of the course and can be taken separately.
After the language sections, we enter the part of the course that covers practical projects.
These practical projects are as close to what you would develop in the real world as possible. This means that these are still small projects that you can comfortably build without spending too much time, but they contain all the building blocks and illustrate all the same design elements that you would have to put in place in a real application.
For example, we are going to build a complete example of a REST API in Node using Typescript and TypeORM, a Typescript-friendly ORM for Node. The server will be designed will all the typical elements of a production system in mind.
For example, the API will be fully secure, and it will require the user to be properly authenticated with a JWT. The API will support multiple levels of access, from a read-only user to an admin user that can edit the data.
Next, once the backend is completed, we are going to build also a couple of frontends with Typescript, namely an Angular frontend, each one in its own separate project.
This way, you will have built your complete system (both frontend and backend) using only one single common language: Typescript.
Table of Contents
This course will go over the following topics:
Introduction to Typescript
The Typescript Type System
The most powerful feature of Typescript: type inference
In-depth coverage of all the Typescript language features, from the most simple to the most advanced
In-depth coverage of all the features available in the Typescript compiler
Object-oriented programming
Typescript Generics in depth
Typescript Decorators in depth
Practical Typescript Project - Secure Node REST API with TypeORM
What Will You Learn In this Course?
In this course, you will learn everything that you need to know to build both the backend and the frontend of your application using the same language: Typescript.
You will know all the features of the language in-depth, and you will be aware of the distinction between the features that you will be using almost every day, from the features that you will only sparingly use.
You will also know in detail the multiple features that you have available in the Typescript compiler.
You will know how to build real-world projects with Typescript, including how to develop your backend with Node and Typescript, and also how to build your frontend in Typescript using modern frameworks.
Have a look at the course free lessons below, and please enjoy the course!
