zx VS TypeScript

I mean, at some point you're going to end up with a bunch of shell scripts in your repo that will dodge the usual type checks & lint rules, and I've wasted quite some time on bugs that would be caught by such safety nets. I think working with bash is too error-prone, even for smaller scripts, and there's a reason why tools like zx exist.

The automatic flattening of Promise> is a minor inconvenience that I faced recently when working with zx scripts (see the Real-life example section in my other article in this series). The root of the problem was that I wanted to get access to the Promise returned from an async function as zx adds methods on that Promise (and calls it a ProcessPromise) and I was unable to, since it was automatically flattened. This led me to evaluate the Promise API and see how different it is from a traditional Future monad.

Python also has a rich ecosystem of ebook parsing libraries, and fairly easily handles things like file renaming, extensions, environment variables on Linux machines, which is what my NAS box runs. And while my first language is typescript/javascript, so I could’ve utilized something like BASH + Google’s ZX, it felt like a good case to try to get some experience with Python, which I’ve never really used. Luckily VS Code’s intellisense (with some Python plugins), and Python’s relatively simple syntax made it quite easy to get from A→ B in terms of getting the pieces all put together.

I stopped writing bash too. I'm writing a lot of TypeScript these days, and for that zx is really cool. I think its Clojure equivalent would be nbb.

I've also done that, as it is the better solution for applications that are meant to be purely single-threaded. It's also easier than dealing with the async version (either promise-based or callback). Or at least it was, before I discovered https://github.com/google/zx.

Personally I seldom write bash scripts so when I do usually have to google how to do everything, and I usually have shellcheck in my editor to catch obvious bad practices. I write js much more often so I’ve used Shelljs to avoid such headaches, though it has its own set of conventions to wrap your head around. Zx looks neat too https://github.com/google/zx . If the scripts are going to be maintained by devs without node experience I’d stick with bash.

There are many alternative shells out there. The popular ones seem to maintain a degree of compatibility with bourne shell and bash, namely dash and zsh. Some deviate even more, like fish. But then I've learned that it is possible to use shells based on regular programming languages. I've seen people using python instead of bash, which initially I thought was weird, but then wondered "why not?". I've also heard about scheme's scsh, and potentially JavaScript's zx. Never tried them, so maybe they're bad examples.

You might be delighted to learn of https://github.com/google/zx :-)

TypeScript

Medusa is based on Node.js and the web framework Express medusajs is hosted on GitHub and written in TypeScript.

TypeScript is a strongly typed programming language that builds on JavaScript. In practical terms, if you already know JavaScript, all you need to learn to use TypeScript is how to use types and interfaces.

It it based on several core technologies - GraphQL for making API calls, Prisma as an ORM, TypeScript for type safety (optional), Jest for testing, Pino for logging and Storybook to assist with creating UI.

We're going to initialise a simple Node.js console application called "tinify" using TypeScript and ts-node:

TypeScript for the language

NestJS is a framework in Node.js for building efficient, scalable server-side applications and also supports Typescript 😍

MultiversX (former Elrond) MultiversX Virtual Machine (EVM) supports any programming language that can compile Web Assembly smart contracts. These include the likes of TypeScript, C#, Go, C/C++, and Rust. However, since MultiversX’s smart contract framework is based mostly on Rust, Rust is the recommended language.

We will use React and TypeScript to build the application and a few services that facilitate the more complex part of the architecture.