TypeScript Certification Training

Benefits of TypeScript

TypeScript is a superset of JavaScript that gives you advantages like:

• Optional static typing (the key here is optional)
• Type Inference, which gives some of the benefits of types, without actually using them
• Access to ES6 and ES7 features, before they become supported by major browsers
• The ability to compile down to a version of JavaScript that runs on all browsers
• Great tooling support with IntelliSense

Optional Static Typing

Most likely, the first thing that comes to mind with TypeScript is the optional static type system that it provides. Types can be added to variables, functions, properties, etc. This will help the compiler and show warnings about any potential errors in code, before an app is ever run. Types also help when using libraries and frameworks, as they let developers know exactly what type of data APIs expect. The key thing to remember about the type system is that it is optional. TypeScript does not force developers to add types they don’t want to add. However, as an app gets larger and more complex, types can provide some great advantages.

Intellisense

One of the biggest advantages of TypeScript is its code completion and IntelliSense. Intellisense provides active hints as code is added. Since Ionic itself is written in TypeScript as well, editors can present all the methods available and what they expect as arguments. All the best IDE’s available today have support for code completion, including VScode, Atom, WebStorm, Sublime text, and even command line editors, such as Vim/Neovim.

Advantages of TypeScript

Going into greater technical detail, TypeScript gives you:

Strict typing

Everything stays the way we define it. Need a variable to always be a number? It’ll always be a number, then.

Structural typing

Indispensable when you care about fully defining the actual structure you use. JavaScript allows for a lot of strange things to be done, so relying on a specific structure is a much safer solution.

Type annotations

A handy way of saying explicitly what type should be used.

Type inference

Implicit typing performed by TypeScript itself, so that your developers don’t need to provide types where the compiler can find them on its own.

Additional features of TypeScript

You’ll be glad to learn that TypeScript isn’t just about types.

Microsoft originally set out to create a language more suitable for large-scale solutions. That was back in the bad old days of ECMAScript 5, which today is synonymous with JavaScript.

Don’t get me wrong, that version of JavaScript was absolutely usable, and it’s still used on the web to this day. But programming in ECMAScript 5 was, to put it mildly, peculiar and particularly difficult for developers coming from fully object-oriented environments like Java or C#.

Microsoft had already been using C#, often referred to as “the better Java,” and getting more and more into server-side applications. On the frontend, though, the most-used solution on the market was JavaScript. This is why Microsoft decided to write a language based on JavaScript, but bearing more similarities to those backend languages.

TypeScript introduced a great deal of syntax taken from object-oriented programming, including but not limited to:

• interfaces,
• classes
• enumerated types
• generics,
• modules

It’s true that ECMAScript 6 introduced some of those features to JavaScript—but not all of them. For instance, abstract classes or access modifiers are still nowhere to be found in JavaScript, while TypeScript has them.

Benefits of TypeScript: Why should you use it?

With its wide selection of useful types and new features, TypeScript is a great tool for JavaScript developers.

But is it worth going into TypeScript when JavaScript works well enough and your projects are doing just fine?

Let’s take a look at the advantages and disadvantages of TypeScript, and how they affect your frontend software development.

Precise defining through typing

When discussing the benefits of TypeScript, we need to start with its most important feature: the typing system You’ve already seen how it looks and how it works; now, we’ll show you why it’s so great.

For starters, we have compile-time errors. You may be asking yourself, “Since when are errors a good thing?” Well, errors can be advantageous when you detect them as early as possible.

Developers who code in languages like C# or Java—with highly advanced and strict type systems—like to make fun of dynamically typed languages, claiming that errors in apps written in those languages are found by the end-user, not the compiler.

Jokes aside, though, this is a genuine issue with JavaScript. Remember the earlier example of adding numbers? That’s just one of many symptoms of this problem; in JavaScript, you’ll only find it once you use the app.

But in TypeScript, when your developer makes a mistake and enters unsupported input into the code, they’ll be made aware of it before pushing the code to the repository. And even if they were to ignore that error, you also have CI/CD systems like Jenkins that can check types and prevent them from being pushed further to production.

The ability to find these obvious yet frequently occurring errors this early makes it a lot easier to manage your code with types.

Types make code management easier

Detecting errors on builds early is only one of many ways developers can benefit from types. Modern development environments like WebStorm can give you more accurate code suggestions.

Even at this level, you can be warned about having type errors in your code. Since the errors aren’t found either by the user or the compiler, but the editor itself, there’s no need for you to perform a build.

Additionally, providing types is a form of documenting code. Having even brief documentation at hand can be beneficial to your developers, at the very least because they don’t need to spend their valuable time doing it themselves. This is often referred to as “self-documenting code”—one developer writes something, and others know what it does and how just by looking at it.

Annotating types also elevates your code to the next level, since we may not always wish to look at how something works in order to use it. Most of the time, we just want to see the definition of how we can use it.

For instance, addNumbers takes two numbers and returns one number. It’s the most useful information you can get from types and code documentation, and TypeScript gives it to you straight away when writing new code.

The benefits of types naturally go beyond mere code. External libraries also work great with TypeScript. It used to be that developers needed to browse through voluminous documentation to learn where a given function is, what they can use and how, or what can be safely overridden. With TypeScript, we get all of this information directly from the development environment, which saves you a great deal of time.

Increased team performance

The great thing about strictly typed programming languages is that they allow your developers to work on their task without relying on the other team members too much. 

Having someone to ask about anything that goes in your project is admittedly one of the greatest advantages of teamwork, but doing it too often is a bad sign. Context switching and asking questions instead of writing code affects performance and causes tasks not to be delivered at the end of the sprint.

Granted, the choice of programming language by itself won’t do you much good if you’re struggling with issues like “spaghetti code” or badly defined acceptance criteria. However, it can help you along the way by providing useful problem-solving tips. It’s also imperative in getting started the right way.

On that note, TypeScript allows you to introduce new developers to your project faster. Explicitly defined data structures and type annotations make it incomparably easier to understand the decisions made by the engineers originally writing your code.

I can tell you from personal experience that whenever I write something new in JavaScript, I usually need to run the code first in order to see exactly what a particular function does and returns. With TypeScript, I can rely on the type definition to tell me everything I need to know.

Using TypeScript increases overall performance—of individual developers and the team as a whole—and higher performance leads to better profits.

TypeScript is popular and trusted by the biggest players in the industry