Disclaimer: I’m not describing the migration process step-by-step or TypeScript itself in this article. You can find many resources on that online, including official TS docs.

JavaScript to TypeScript migration strategy

If you search online, you will find many possible strategies of migrating JavaScript to TypeScript. We considered two of them:

• converting the whole JavaScript codebase to TypeScript at once
• starting to use TypeScript compiler and migrate step-by-step.

After a short discussion, we decided to go with the step-by-step migration strategy. Why? First, it’s less time-consuming. Today, we know that it would kill us if we decided to convert all our JS codebase to TS at once. It would also freeze our codebase for a while – until every .JS(X) file is renamed to .TS(X) and all compile errors are fixed.

Thanks to the fact that TypeScript is a superset of JavaScript, .JS(X) and .TS(X) files can co-exist even if you switch to use TypeScript compiler. That’s because every JavaScript is also a valid TypeScript code and TS compiler can handle it.

That’s very comfortable. Just think about that – you can switch your project to TypeScript without actually having to change any code. We decided to immediately re-write a few of our recently-added functionalities to TypeScript and convert the rest gradually.

What TypeScript gave us

Before I tell you about the struggles, I want to really encourage you to migrate JavaScript to TypeScript. After 1 year since we switched to TypeScript, I’m telling you it’s the best thing you can do to your web app ?

Let’s see what you’ll gain if you decide to migrate JavaScript to TypeScript.

Types in new code

As soon as you switch your compiler to ts-loader, you can start creating files with TypeScript extensions (.TS, .TSX). It means that all your new code can now leverage types:

Enjoy ?

Typing information for existing libraries

Have you been wondering what about the external libraries you are already using? How to get types for them? I was thinking exactly about this before migration.

It turns out that after you migrate JavaScript to TypeScript, most of the npm packages you use already have built-in typing information. You can check it on your package’s npm page:

If it doesn’t, you can try installing npm package called “@types/your_library_name”, e.g. npm i @types/backbone.

As a last resort, you can create the declaration files yourself.

JavaScript-TypeScript coexistence

A huge benefit of TypeScript is that JavaScript code can co-exist with it. If you are like we were a year ago, with a lot of legacy JavaScript code and are afraid of switching to TS – don’t be. TypeScript makes it very easy to maintain your JS codebase or even mix it altogether.

There are no issues in using JavaScript code in TypeScript and otherwise. You can even use JS components in TypeScript. We used to have a services.js file where we kept “services” exported as follows:

After migrating it to TypeScript (meaning renaming to services.ts) it turns out that these two definitions can co-exist, even in the same file:

As you can see, we added typing information to the legacy StockService as well. That’s because we have noImplicitAny enabled in our TypeScript configuration. It doesn’t allow leaving any variables which are of any type. In any case, if you don’t know what type to use for a given variable/function, you can always type it explicitly as any, while moving the new code to fully-typed equivalents. That’s the power of TypeScript ?

Compile errors

I should have started with that! It might be obvious, but not for people who only worked with JavaScript on the frontend before ? Sure, you could get suggestions and warnings with ESLint, but that’s not the same as really enforced types checking on compilation level:

Many TS compiler options

TypeScript compiler has many useful configuration options. If you want to support JavaScript alongside TypeScript, you should enable allowJs. We have already mentioned the noImplicitAny setting that forces you to always explicitly specify types in your code. There’s much more stuff helpful in various scenarios of JS-TS migration. We were having some issues with imports from modules without default exports – enabling allowSyntheticDefaultImports saved us there.

What I’d like to emphasize here is that TypeScript compiler is really helpful ? It allows you to set your “typing” level by enforcing less or more rules. Thanks to that, you can slowly move towards more strict type checking rules like noImplicitAny. You’re not forced to do that from the beginning.

Better coding experience

This is definitely the best thing about TypeScript. It just feels more right to use it than coding in plain JavaScript. I see no reason to start a new project with vanilla JS today. I’d say even more – I see no reason to not migrate your JavaScript app to TypeScript. The sooner, the better!

You can catch your errors earlier. No need to debug the code to see if the property you used actually exists on an object. Your IDE gives you code completion suggestions. It’s a pure pleasure ?

Migration challenges

Of course, we met some challenges during migration. I don’t call them issues, because they are all manageable. Many people have already done those things, so you can find solutions to almost any issue online. Let’s see what we had to overcome.

webpack configuration

If there’s something I don’t like about web development, it’s definitely webpack... This is a typical “fighting with machines” case. Poor documentation, lack of well-described solutions online and some specificity in every project.

We had problems with babel-loader which we used to transpile JavaScript files before switching to TypeScript. Initially, afraid of introducing a regression, we wanted to keep babel-loader for legacy JS files. We couldn’t make it work, so we decided to switch completely to ts-loader for all files (including JavaScript ones).

Next issue was a lack of proper source maps and problems in debug mode. The breakpoints were often not hit. After a bit of searching and trial-error sessions, we found a solution. It was necessary to modify webpack.config.js and set devtool webpack setting to eval-source-map. We also had to use source-map-loader for JavaScript files. Finally, this webpack configuration solved the debugging problems:

You need to be really patient with webpack… But if you have already worked with it, I guess you know that very well ?

Adding types to legacy JS code

Adding types information with noImplicitAny set to true is sometimes challenging. Especially if you have some bigger JS files with no typing information at all. Sometimes you need to search for function’s calls to find out of what types are its parameters. In other cases, you might need to run your app and see that at runtime ?

Fortunately, as we already said, TypeScript doesn’t force you doing that. You can play with tsconfig or use @ts-ignore as a last resort.

Handling libraries without types

Some of the libraries we used don’t provide any typing information. It makes working with them a bit difficult, especially if your TS compiler is already configured in a bit stricter mode. In such case, you might get an error similar to the following one:

Your options here are to either write the declaration files yourself, or import the library differently. You can, for instance, require it:

const FormIO = require('react-formio');

and then use this FormIO variable which is typed as any. Again – that works because of TypeScript’s flexibility, but might not be very comfortable to live with.

Migrate JavaScript to TypeScript – should I do it?

Of course! There’s only one right answer. Don’t wait too long – start being more productive with TypeScript as soon as you can ? Believe me – you will not regret it.

The post Migrating JavaScript React App to TypeScript appeared first on Yumasoft.

The problem

Let’s say that we install @ckeditor/ckeditor5-build-classic npm package to our web app. This is a kind of package that has many forks. Some companies or individuals fork ckeditor5-build-classic repository and create their own versions of it, adjusted for use with their products.

The problem is that if you use such a product that has their own fork of @ckeditor/ckeditor5-build-classic, you might want to use this fork as npm package, not the original npm library. However, in most cases there’s no npm package published for the forked repository.

We need a way to replace the contents (source code) of the original npm library with contents (source code) from the forked library (custom version). Let’s see how to replace npm library with our own code.

The solution

The first idea that comes to mind could be to create a modified private npm package and use it in our project. However, it requires some maintenance and forking the original library. We found a better solution.

If we go to node_modules folder looking @ckeditor/ckeditor5-build-classic package’s source, we can see that its source files (bundles) are present in node_modules\@ckeditor\ckeditor5-build-classic\build\ folder:

If you check some forks of this library on GitHub, there are also bundles present there, e.g. here or here. Let’s say that we need to take the forked version of ckeditor.js file and replace this file in our original npm library. How do we do that?

patch-package

To achieve this, we need to install patch-package npm package. This is an awesome, life-saving tool created just for what we need. Kudos to our teammate Przemek who recommended this gold tool to me ?

After installing the package with npm i patch-package, we can simply go to our npm library’s source and modify it. In our case, we replace node_modules\@ckeditor\ckeditor5-build-classic\build\ckeditor.js file contents with the contents of ckeditor.js file from our forked library (for example with this one). After that, we save the file.

The last step is to generate a patch for our original npm library. We do it by executing the following command: npx patch-package @ckeditor/ckeditor5-build-classic (replace @ckeditor/ckeditor5-build-classic with your package name). This is how it looks:

We can now see that a new folder called patches was created in our web app’s directory. In our case, it contains only a single patch file:

What’s interesting, this file is basically a git diff between the original and modified ckeditor.js files:

When we now execute npx patch-package command, the changes we’ve made before are applied to the actual npm library’s files:

This is great, because we can now add this command patch-package to our build script, so our custom changes to the libraries are applied on every build. It’s very quick and works like a charm. That’s how we managed to easily replace npm library with our own implementation ?

We should check in the patch files to our GitHub repository, so our teammates have them locally and our build server can also apply the patches.

Since this moment, we modified the npm library’s code, so everyone who imports and uses this library in our app will be actually using our modified version of it.

If needed, we can easily revert the changes with npx patch-package –reverse. It restores the npm libraries to their original versions (thanks to the patch file stored as git diff).

Summary

I hope you found this article helpful. You can use the patch-package library not only to replace the npm library’s source files, but also as a quick-fix for bugs found in these libraries. No need to wait for the open-source community to fix the issue or the PR to be merged. You can make the patch quickly and at the same time report the issue on the concerned package’s GitHub. The tool even offers a feature to create a GH issue in the original repo with the diff containing your changes by using command npx patch-package package-name –create-issue.

For us at Yumasoft, the patch-package is a life-saver. Maybe it also saves you some headache? ?

The post How To Replace npm Library With Your Own Implementation? appeared first on Yumasoft.

MDN web docs

The most recognized JavaScript resource is MDN web docs (MDN stands for Mozilla Developer Network) provided and maintained by Mozilla Corporation. While other programming languages usually have their official documentation, JS doesn’t have one (It actually depends od how do you treat ECMAScript, because it has official documetation). And the reason behind it is that a few teams worked on developing JS. But nevertheless, we have MDN web docs website, which is almost treated like official documentation for the JavaScript community. Information provided by maintainers is truly comprehensive. In my developer career, I have never experienced lack of crucial information on subjects of interest. What is more, this website provides sufficient tutorials for web development including JavaScript, HTML and CSS, divided into different levels of expertise.

Links:
MDN: https://developer.mozilla.org/pl/
Tutorials: https://developer.mozilla.org/pl/docs/Web/Tutorials

ECMAScript docs

ECMAScript was created to simply standardize JavaScript, because maintaining multiple independent implementations would be unbelievably hard without some sort of a standard. In ECMAScript docs you can find what JavaScript should look like and in almost every case it does. For example the latest official release of ECMAScript is named ES2020. Ecma international also provides information about future additions to the standard under the name ESNext. Technically the ECMAscript docs are the closest you can get to the official JavaScript docs. I personally wouldn’t recommend reading them for beginners, because complicated language and covered subjects might seem a little underwhelming.

Links:
Newest ECMAScript Docs: https://tc39.es/ecma262/#sec-fundamental-objects

Javascript.info

Javascript.info is a great and clearly made tutorial website. The tutorial itself covers JavaScript as a programming language and matter of working with a browser. The amount of information crucial to gain essential knowledge is perfect. I would say, if you want to maximize your learning speed, javascript.info is a right choice. In comparison to MDN docs, it is easier to get essentials and don’t get overloaded with information. Additionally, almost every topic has some bonus, usually it is some trick that is hard to invent on your own or explanation of unusual JavaScript behaviour. In my honest opinion, this site is the best way to start learning JavaScript – In my case it was a turning point.

Links:
Javascript.info: https://javascript.info/

Codecademy

Codecademy is an interactive learning site. You can take courses on a large amount of languages, but we are interested in JavaScript. If you are starting from scratch it is a way to go. Easy and well explained tasks will softly inaugurate you. The biggest advantage of this site is that you don’t need any code environment, you just write your code inside a special container right on the website. At the beginning, you already have some code written and you just have to change something or insert some variable or value, which sets the entry threshold really low. The downside of codecademy is “PRO” content, if you want to have access to everything, you must upgrade your account to PRO status and the lowest-priced upgrade costs 19.99$ a month.

Links:
Codecademy: https://www.codecademy.com/

Udemy

Video based tutorials have gained huge popularity in recent years. This form of studying is known as the easiest and really effective, so the huge increase in popularity is understandable. Udemy is a great online learning platform with a wide range of courses. It doesn’t only have videos, online tests, zip packages with source code and community conversations are a huge part of Udemy success. There are some free courses, but the better ones are paid. The prices are really high, but you can encounter 90% discounts almost every two weeks.

Links:
Udemy: https://www.udemy.com/

Some valuable udemy courses:
https://www.udemy.com/course/modern-javascript/
https://www.udemy.com/course/modern-javascript-from-the-beginning/
https://www.udemy.com/course/js-algorithms-and-data-structures-masterclass/
https://www.udemy.com/course/javascript-beginners-complete-tutorial/

Codewars

Learning by doing is pretty good, but if you ask me, learning by doing and competing is just amazing! Codewars is an online learning site, where you can complete challenges, get points for it and compare your solution to others. The challenges are divided into different levels of expertise and your account has a level itself to give you proper tasks. You can get better by completing challenges, but the amount of knowledge gained through studying solutions made by more advanced people is huge. Some code pieces you will find there will change your way of thinking and present you unthinkable actions. You can’t miss codewars!

Links:
Codewars: https://www.codewars.com/

W3Schools

W3Schools is an old-school tutorial page. You can start your web development path using this webpage, but you will run out of resources quickly. Topics are explained quite well for beginners, but explanations are simple and minimalistic. Lack of crucial topics are enough to say W3Schools is insufficient for more advanced people. Nevertheless, this webpage is worth checking.

Links:
W3Schools: https://www.w3schools.com/
JS tutorial: https://www.w3schools.com/js/default.asp

Youtube channels

It is an unlimited source of knowledge. You can find a huge amount of tutorials, explanations and examples on youtube. Some youtubers even upload some of their content from Udemy, so it is good to pay attention to several channels. I personally really enjoy crash courses on youtube, you can choose some technology and get essentials in under two hours.

Good channels:

Fun Fun Function: https://www.youtube.com/channel/UCO1cgjhGzsSYb1rsB4bFe4Q
Traversy Media: https://www.youtube.com/user/TechGuyWeb
freeCdeCamp.org: https://www.youtube.com/channel/UC8butISFwT-Wl7EV0hUK0BQ
Udemy Tech: https://www.youtube.com/channel/UCU6e4MJtvlcX5DBLP1cq8hQ
Academind: https://www.youtube.com/channel/UCSJbGtTlrDami-tDGPUV9-w
Dev Ed: https://www.youtube.com/channel/UClb90NQQcskPUGDIXsQEz5Q
The Net Ninja: https://www.youtube.com/channel/UCW5YeuERMmlnqo4oq8vwUpg
Techsith: https://www.youtube.com/user/techSithTube

Summary

There are a lot of javascript resources. They may vary within the quality, but all of them are worth trying. In my opinion, dividing your time into different resources gives the best results in the studying process, because you avoid monotony. I will try to pick the best choices in some categories and write them below.

Most comprehensive docs and tutorials: MDN web docs / ECMAScript docs
Most efficient tutorial: Javascript.info
Best for beginners: Codecademy

The post Resources to learn JavaScript appeared first on Yumasoft.