Determine and Publish Core Team Dev Stack

[EricEisaman]

CORE TEAM DEV STACK OPTIONS:

Containerization:
Docker, Kubernetes

JS Runtime:
Node, Deno, Bun

Mono-Repo Management:
pnpm, nx, nx podcast info

Build Tooling
Webpack, Vite, Rollup, Bun

[DylanBulmer]

Containerization:
I have a k8s cluster, so I'm perfectly happy using both Docker for containerizing and k8s for container orchestration.

Runtime:
Here are my thoughts:

• NodeJS -- Well supported, but quite slow in comparison to other options
• Deno -- Built-in TS and WASM support, starting to pick up traction by the community
• Bun -- Very fast, but they state it's not suggested to use in production yet

I'm cool with trying out Deno now that it's been fully released, but this will limit us on what frameworks we can use.

Mono-Repo Management:
I switched to a multi-repo approach, probably because I'm not familiar with these tools, but I'm cool with using whichever you guys feel fits best!

Build tooling:

• Webpack -- well used, but I know many are seeking alternatives because it's quite slow.
• Vite -- I feel that this tool is quite well supported and starting to be widely used.
• Rollup -- I have never heard of it before this project, but it seems well supported.
• Bun -- In their documentation, they stated they do not yet have tree-shaking and minifying builtin.
• SWC -- From my experience: does not export .d.ts files for JS back-support, and swcpack is not quite stable yet, but does have minification.

I think Vite or Rollup is our best option to start; switching tooling is not very hard. I was able to switch from webpack to swc in about an hour in my personal projects.

[EricEisaman]

Thanks for your input @DylanBulmer . I like the idea of k8s for developing a basic service mesh for the open-source backend. I will do some explorations with Vite soon.

[DylanBulmer]

Here are some of my ideas:

Potential dev stacks with deployment strategies in mind (necessary to know now, so we don't need to go back in the future refactoring all our code).

Approach 1 (Node container):

Runtime: Nodejs
Web framework: Expressjs
Websocket framework: SocketIO
Bundler: Vite or Rollup
Containerization: Docker
Deployment: Kubernetes (AWS EKS or similar)

Approach 2 (Node serverless):

Runtime: Nodejs
Web framework: Expressjs and serverless-express
Websocket framework: SocketIO
Bundler: Vite or Rollup
Deployment: AWS Lambda (or similar)

Approach 3 (Deno container):

Runtime: Deno
Web framework: Oak
Websocket framework: deno-websocket
Bundler: Deno? Minify is WIP
Containerization: Docker
Deployment: Kubernetes (AWS EKS or similar)

Approach 4 (Deno serverless):

// I cannot find a quick tutorial that integrates WebSockets into a serverless application
Runtime: Deno
Web framework: deno-lambda
Websocket framework: deno-websocket
Bundler: Deno? Minify is WIP
Deployment: AWS Lambda (or similar)