Technology Minimalist

#javascript #programming

Instead of keep adding new layers, there is a trend to go the opposite direction

Library over Framework

We used to think reuse is a good thing. Now more and more people realise reuse cause more damage than good. There are good reasons

UI design is highly volatile. More and more things become "headless" because we just want the stuff without the "style"
Big framework controls the control flow, making the debugging process mysterious.
Implement your requirement using options/callbacks provided by other guys is not fun. It takes time to memorize the options/callbacks and sometimes there isn't any.

Reuse is still going to happen, just in a more granular way. The UI will be ripped out, the framework will be teared apart, left us with a lot of highly focused libraries which just solve one problem one time.

Boring over Fancy

We used to think adding a new fancy technology will always be a good thing. Now more and more people realise they just need to get the job done with the least amount of moving parts.

Do we always need nosql or hadoop? Can we get the job done with postgresql with some extensions?
Do we always need SPA? Can we get the job done with server generated HTML?
Do we always need another microservice? Can we get the job done by extracting out a library?

Choosing boring technology is not just about stability, it is also about better developoer experience. With less compilation unit, less runtime service, and less co-workers, the job will be a lot easier.

Copy-paste is underrated

We used to think there could be another SaaS, another product, another library to build another abstraction, to make the reuse happen. Well, because we all hate to start from scratch again and again.

Between starting from scratch and reusing a library, there is a middle ground called "copy-paste". We all have used this approach, but shame to admit it. With the aid of github co-pilot, this kind of reuse will be more and more common.

Encapsulation can be cheap

We spent a lot of effort to combat with increasing complexity of legacy code. We want to entangle the codebase by enforced encapsulation. So there was a fashion to start a new project with 100 and more micro-services.

It does not have to be that expensive to enforce encapsulation. With the help of TypeScript and other static type checker, we can enforce encapsulation at compile time without paying runtime cost. Hide some internal implementation details through package.json dependency relationship is not a rocket science, it is called "dependency management".