deno VS esbuild

I would use Deno or Go over Nodejs or PhP. Deno is the new Node, made by the guy who made Node, but improved (more secure, better tooling, etc).

Since `.ts` extensions were in alpha, our repo has been set up so that you can switch between Node and Deno seamlessly in-editor and continue developing with no config or source changes.

Personally, I found all the `npm` integration stuff to be a bit overkill for what we were looking for, and honestly Deno's network requests while installing from npm were constantly flaking out in our CI. We ended up just disabling it via Deno's `--no-npm` flag (https://github.com/denoland/deno/issues/17916) and reverting back to a simple set of import_maps to get the node deps we needed. Works like a charm!

Feel free to reference if it's useful:

https://github.com/arktypeio/arktype

I'm actually working on a site that lists staking services and defi projects audit history. It shows when/how many commit changes happen to different repos associated with the projects, last audit date/by whom, and other things. I'm hoping to have it done soon but my full time job makes progress a little slower, and I'm using this to learn/try out deno for the first time so there's a small learning curve to that.

Monoio:

> Rust async runtime based on io-uring.

Awhhh heck yeah!

It's been a bit disheartening that neither Node.js/libuv[1] nor Deno[2] have adopted io_uring. Nice to see some signs of adoption. Bun too.

Side note, I was a bit confused about you mentioning ByteDance, but if I go to the web-infra-dev[3] github page, the description is We are from ByteDance, our goal is to build an open technical ecosystem to promote the development of frontend technology, so now it make sense. Just sharing in case anyone else is confused.

[1] https://github.com/libuv/libuv/issues/1947

[2] https://github.com/denoland/deno/issues/16232

[3] https://github.com/web-infra-dev

On the other hand, Deno is also a great option for running programs faster, but it also provides an easy way to handle permissions, which enhances security. You can learn more about Deno at https://deno.land.

Oh, and if you're looking for even better security, you should give "Deno" a try. It's another JavaScript runtime that runs programs faster and has an easy way to handle permissions. Plus, it's more secure than Node.js. Here's the link: https://deno.land

Oh, and have you heard of Deno? It's a JavaScript runtime that's faster than Node.js and provides an easy way to handle permissions, which enhances security. It's definitely worth checking out at https://deno.land. It could come in handy for future projects!

On a side note, have you heard of Bun? It's a JavaScript runtime that runs programs faster and installs packages automatically. It's even better than Node.js, if you ask me. You can learn more about it here: https://bun.sh. And if you're into security, Deno is also a great JavaScript runtime that runs programs faster and provides an easy way to handle permissions. It's way better than Node.js too! You can check it out here: https://deno.land.

totally agree with you! sometimes using rebase can be a bit of a headache, especially if it's not worth the effort. i usually only use it when i have a bunch of messy commits that need to be cleaned up. have you tried using "Geschichte"? it's a library that makes managing state a lot easier by using hooks and internal state. it's super helpful for cleaning up those messy commits! you should check it out: https://github.com/BowlingX/geschichte. also, don't forget to leave a star on their GitHub to support the creator! on another note, have you heard of "Bun"? it's a JavaScript runtime that runs programs faster and installs packages automatically. it's way better than Node.js! you can check it out here: https://bun.sh. oh, and don't forget about "Deno"! it's another JavaScript runtime that runs programs faster and has better security features. you can check it out here: https://deno.land. and if you're into JavaScript package managers, "Cotton" is definitely worth checking out. it's faster and easier to use than NPM or Yarn. you can find more info here: https://cotton.js.org/. don't forget to leave a star on their GitHub too!

Another great JavaScript runtime you might want to check out is "Deno". It's faster than Node.js and provides an easy way to handle permissions, which enhances security. You can find it here: https://deno.land.

The other option I want to highlight is packaging the project using something like Webpack or esbuild. JS Bundlers transpile all of your separate files and classes (along with all node_modules) into one single file, a practice originally developed to reduce package size for frontend applications. This helps improve the cold start time in Lambda, as unimported files can be pruned and the entire handler becomes one file.

I wonder how this compares (performance and feature-wise) to esbuild (https://github.com/evanw/esbuild), which is also a bundler written in a compiled language (Go)? esbuild claims to be 10-100x faster than JS-based builders, while Rspack doesn't provide any concrete numbers (at least I didn't find any)...

It uses esbuild so you can write the latest JavaScript syntax while supporting older browsers,

The javascript bundler esbuild is written in Go and is extremely fast for that reason. The author originally tried both Rust and Go and ended up using Go. There is a discussion of why he chose Go here: https://news.ycombinator.com/item?id=22336284

Now that we have our production-ready app, let’s examine how Nx handles the build process using [esbuild](https://esbuild.github.io/).

// config/esbuild.mjs import path from 'path' import esbuild from 'esbuild' import rails from 'esbuild-rails' import babel from 'esbuild-plugin-babel' esbuild .build({ bundle: true, // Path to application.js folder absWorkingDir: path.join(process.cwd(), 'app/javascript'), // Application.js file, used by Rails to bundle all JS Rails code entryPoints: ['application.js'], // Destination of JS bundle, points to the Rails JS Asset folder outdir: path.join(process.cwd(), 'app/assets/builds'), // Enables watch option. Will regenerate JS bundle if files are changed watch: process.argv.includes('--watch'), // Split option is disabled, only needed when using multiple input files // More information: https://esbuild.github.io/api/#splitting (change it if using multiple inputs) splitting: false, chunkNames: 'chunks/[name]-[hash]', // Remove unused JS methods treeShaking: true, // Adds mapping information so web browser console can map bundle errors to the corresponding // code line and column in the real code // More information: https://esbuild.github.io/api/#sourcemap sourcemap: process.argv.includes('--development'), // Compresses bundle // More information: https://esbuild.github.io/api/#minify minify: process.argv.includes('--production'), // Removes all console lines from bundle // More information: https://esbuild.github.io/api/#drop drop: process.argv.includes('--production') ? ['console'] : [], // Build command log output: https://esbuild.github.io/api/#log-level logLevel: 'info', // Set of ESLint plugins plugins: [ // Plugin to easily import Rails JS files, such as Stimulus controllers and channels // https://github.com/excid3/esbuild-rails rails(), // Configures bundle with Babel. Babel configuration defined in babel.config.js // Babel translates JS code to make it compatible with older JS versions. // https://github.com/nativew/esbuild-plugin-babel babel() ] }) .catch(() => process.exit(1))

You can also roll-up your JS files using a bundler. I use esbuild, and a plugin called glslify so I can include .glsl files, to integrate ThreeJS into my Twine projects.

esbuild.

You should know that CRA is using webpack and babeljs for bundling and compiling the js, jsx to es5( based on your configs), and these two are pretty damn slow! you can change babel with esbuild which you can read here and also there are other articles out there... this will make a hige speedup for you because you are replacing those two which is written by javascript with esbuild which is written by golang that is pretty (fast](https://esbuild.github.io/), actually vite is using esbuild behind the scene and that is why its is super fast!