wizer VS go

> once by the wasm runtime to compile the rust-python wasm

I'm not sure what you mean by that. The runtime doesn't compile WASM, it simply executes it.

There are tools for dealing with interpreter runtime overhead this by pre-initalizing the environment like Wizer[0]. ComponentizeJS[1] uses it to pre-initialize the Spidermoney engine it packages to gain fast startup times (and you can then prune the initialization only code with wasm-opt). As techniques like ComponentizeJS are also being applied for a specific set of interpreted files, you can even prune parts of the interpreter that would never be used for that specific program. If you want to go even further you could record specific execution profiles and optimize further by those.

[0]: https://github.com/bytecodealliance/wizer

[1]: https://github.com/bytecodealliance/ComponentizeJS

Edge functions are typically run intermittently, with their runtime stopped to free up resources between runs. Therefore a big factor is startup and shutdown speed. Containers are pretty bad there. Deno is better, and WASM is unbeatable, especially with things like Wizer[0].

[0]https://github.com/bytecodealliance/wizer

I imagine startup cost could be amortized by something like wizer: https://github.com/bytecodealliance/wizer

There are security benefits to running each request in its own instance, as it helps prevent accidental leaking of state between requests. To avoid doing lots of expensive initializations, we have a tool called wizer which lets users run their program's initialization once, create a snapshot, and then use that snapshot to do fast startups that don't rerun the whole initialization each time.

See https://github.com/bytecodealliance/wizer for an implementation of this approach.

It should probably be named "Making JavaScript to startup fast on WebAssembly", since the runtime speed is not really improved by the approach they exposed.

Besides that I think Wizer [1] is both an elegant and a simple solution to speed up startup speed with Wasm.

[1] - https://github.com/bytecodealliance/wizer#using-wizer-as-a-l...

A similar project, for WebAssembly so with limited scope is this: https://github.com/bytecodealliance/wizer. And somehow similar but limited on LLVM IR a colleague worked on this for Cheerp (the compiler used here as backend): https://github.com/leaningtech/cheerp-meta/wiki/Cheerp-PreExecuter.

Basic knowledge of Go and its concepts.

I love Go's templating system for its simplicity and frankly being part of the stdlib. I am however in need of a parser extensions. I created a proposal for this (https://github.com/golang/go/issues/59453), but like many large open source projects, the proposal queue is substantial with uncertain review timelines. I'm considering forking just this part of the stdlib to implement my needed changes in a backward-compatible way.

This raises a broader question: At what point do you decide to fork and maintain your own version versus waiting for upstream acceptance? What has been your experience with similar situations, especially when dealing with core libraries or language features?

I guess one sure reason to fork it is if the proposal is completely shot down and for some reason the proposer absolutely cannot live without it - but let us not go that far!

As a web developer, I learnt how to use NodeJS for my apps' back-end. But in 2025, I decided to learn Go, and I will detail in this post why.

I think most of the language implementers know about it.

Here is a relevant line from Go, even with a comment that it's about overflow:

https://github.com/golang/go/blob/19e9231/src/sort/search.go...

If you're working at a large company and downtime is extremely expensive, this checklist is a good guide. Otherwise, if you have good test coverage, you can get by with something simpler. It's super rare to have a breaking change in go.

We do quarterly upgrades of all services in a monorepo (about 20-30). The steps are basically this:

- Upgrade all dependencies to their latest versions, fixing build and test breaks (I read release notes for Go, but not for dependencies)

- Look for deprecated packages and replace them

- Upgrade all toolchains, including CI/CD containers, go.mod, etc.

- Run all tests

- Deploy to the test environment and make sure everything is green

- Deploy to staging and do some sanity checks

- Deploy to prod, keeping an eye on metrics for an hour or two

We're on k8s and the state of all clusters (i.e. which images are running) is tracked in git, so a rollback is just git revert + apply.

In practice, after about four years of this, we've seen maybe a dozen build breaks, and I can only remember one regression caused by a breaking change in a library[1].

[1] https://github.com/golang/go/issues/24211

1. The Official Design of Not Having goid(https://github.com/golang/go/issues/22770)

For those who don't know, Golang (Go) is a programming language designed at Google in 2009. It is syntactically similar to C.

Like Go, Deno, and Rust, V produces executables that run on Linux, Mac, and Windows.