jurigged VS ncc

If that interests you, I made a package called jurigged that basically does autoreload but asynchronously on Python in general (i.e. you can write jurigged script.py instead of python script.py; it works in a separate thread and can also work in notebooks). It's more surgical than what the notebook does in that it only hot swaps code in changed functions and does not re-execute anything else. This feature is cool too, IMO.

Some of the basic hot-loading features can probably be approximated in Python. Here's some from my bookmarks(i've not tried them personally)

- https://github.com/breuleux/jurigged

- https://github.com/reloadware/reloadium

I would imagine lisp can do this on a whole different level. Emacs seems like a testament to that. Basically the entire editor feels like eval()

I've been using jurigged [0] for hot code reloading which is great. It works by replacing code objects in place at the function level which naturally handles many cases like applying to existing objects, avoiding loading a module multiple times, etc. As others noted the actual source of this one is not there so it's hard to know what it's doing. The published package contains a binary shared library so I suppose it's written as a CPython extension.

[0] https://github.com/breuleux/jurigged

During my search for deploying Lambdas via GitHub actions, I came across a tutorial that utilized ncc for converting TypeScript and bundling. While ncc is effective, I discovered esbuild, which proved to be significantly faster and perfectly suited to my requirements.

You could use ncc to compile a binary:

https://github.com/vercel/ncc

This appears to be caused by lazy loading of image layer data, particularly during container initialization, and latency introduced by the read operations. In general, you want to access as few files and as little data as possible during the initialization of your functions. For example, we've seen improvement when using ncc to bundle Node.js applications.

What we do however, is bundle all these dependencies, and our own code into a single JS file using the nifty ncc tool (thanks Vercel!)

Vercel's ncc compiler

The most unclear and confusing part is packing the code using ncc. The necessity of this step is caused by GitHub’s approach to running your Action.

I filed an issue for the ncc bundler regarding a similar behavior

This may be slightly tangential but I recently discovered ncc[1] from vercel which can take a single node project and compile it and all dependencies to a single file.

As an added benefit it also collapses all contained dependencies license files into a single licenses.txt file too!

- [1] https://github.com/vercel/ncc

The current process of building a package locally is by running through a gulp task, using ttypescript to compile the TS and @vercel/ncc to build the binary: