typescript-eslint VS node-clinic

TypeScript Best Practices

Here’s some relevant discussion about some of the footguns:

https://github.com/typescript-eslint/typescript-eslint/issue...

https://github.com/tc39/proposal-explicit-resource-managemen...

I imagine there will eventually be lint rules for this somewhere and many of those using such a modern feature are likely to be using static analysis via eslint to help mitigate the risks here, but until it’s more established and understood and lint rules are fleshed out and widely adopted, there is risk here for sure.

Seems a bit like popular lint library maintainers are overly wary to add rules before it’s better understood through wider adoption and potential adopters are wary of using it until footguns are mitigated — not quite a standstill but maybe not great either

However, I prefer more thorough rules like checking unused type imports or type narrowing problems. In order to enable these checks, we need to tweak eslint.config.js. I prefer simply adding recommendedTypeChecked config to the project. Don't forget that you also need to adapt parserOptions to this change.

EsLint: New to ESLint? It helps you write better JavaScript and TypeScript. https://typescript-eslint.io/

For ESLint + TypeScript ESLint, with the new flat config eslint.config.js:

Typescript-eslint can assist in this task. This tool helps identify all instances of unsafe any usage. Specifically, all usages of JSON.parse can be found and it can be ensured that the received data's format is checked. More about getting rid of the any type in a codebase can be read in the article Making TypeScript Truly "Strongly Typed".

> Only lint files that have changed? How hard that is?

Quite hard, especially since type-aware rules from e.g. https://typescript-eslint.io/ mean that changing the type of a variable in file A can break your code in file B, even if file B hasn't changed.

The article only touches this: when converting to TypeScript, `any` is useful, but in the end you don't want this type in your codebase - so don't forget to use typescript-eslint [0] and turn on those no-unsafe-* rules which guard against `any` leaking into your code.

[0] https://github.com/typescript-eslint/typescript-eslint

clinic.js: visualizes your app’s performance and identifies event loop blocks, CPU spikes, and memory issues.

Node Clinic is an excellent tool for profiling Node.js applications. It offers multiple tools like:

Node.js thrives on its event-driven, non-blocking architecture. However, blocking the event loop with synchronous operations can cripple performance. Use tools like the node-clinic suite to identify bottlenecks. Offload CPU-intensive tasks to worker threads using the worker_threads module to keep the main thread responsive.

Clinic.js was promising but it's not maintained anymore, would be great if we had a modern alternative: https://clinicjs.org/

It's basic, but it works. You can see what function or 3rd library is after your resources and debug them locally (For example, by using ClinicJS - https://clinicjs.org/)

Clinic.js

Clinic.js - performance analysis tooling.

I’ve also seen some pretty bad event loop saturation causing significant delays. Run this https://clinicjs.org

Clinic.js includes three tools to help diagnose and pinpoint performance issues in Node.js applications. It’s surprisingly easy to use. All you need to do is install the module from npm and run it. This will generate reports for you that make troubleshooting much easier.

To compare the two servers, we used two packages. The first one was ClinicJS, an open-source set of tools used to diagnose NodeJS performance issues, which also gives you suggestions and points you in a direction to fix the diagnosed problems. The second one was hey, a CLI tool to send some load to the server. Below we show how we use them and the results of these comparisons.