Also curious! I was also wondering if criu frozen containers would help here. I.e. load the notebooks, snapshot them, and then restore them.

This is notoriously hard when you start to involve GPUs

knockout js is that you?

I was about to mention this too.

Compare: "import a specific lightweight library and wire together as needed" vs "write the whole app in terms of a bloated framework".

I've been out of the frontend game for a while, but what does react give you that knockout and maybe some url management logic do not?

I guess components are supposed to standardize modularity, so you can easily import some random widget?

The biggest downside of knockout is that it parses the template from the dom, and the template is rendered as dom until first execution. Then that it eval it's bindings. I suppose tko should help with those issues but seems kinda dead. Knockout reactivity primitives are also a lot more naive then modern signals implementations.

Rich Harris of Svelte often mentions Knockout when talking about Svelte’s signals.

how many permutations of Fe dev do we need?

- auto rerender by comparing trees?

- track all changes by signals?

Good work! Needed this today

Sounds like LinkedIn story to me. Written by claude trying to drive a point home.

Not sure how to react. This is the second time in a month that someone thinks I used AI to write an HN post.

All I can say is that I didn't, and thank you for implying that it was so well written that it could only have been authored by a machine that has all of humanity's cultural output to hand.

Sorry about that, will be more considerate in the future

I like it but I always miss features or defaults like: - internal network only with edge nodes (i.e tail scale out the box, + some edge nodes) - option to deploy on multiple servers to scale with super simple non k8s approach.

> - internal network only with edge nodes (i.e tail scale out the box, + some edge nodes)

Can you help me understand that?

> - option to deploy on multiple servers to scale with super simple non k8s approach.

I'm working on that, allowing you to manage remote nodes from a single /dev/push instance.

> Can you help me understand that?

Like 10 nodes behind tailscale/wireguard in a private network, with only 2 nodes where you have a port open on 80/443, those are exposed to the public network. The rest of the nodes are all private like db, redis, etc etc.

Still figuring it out. Routing the traffic is the annoying bit.

Guess that is why there isn't an easy go to solution yet. But it's well needed.

Check out https://github.com/psviderski/uncloud I'm building. Multi-machine deployments and a private WireGuard network spanning locations (even behind a NAT) are its core capabilities.

doesn't this make the language a little unpredictable in terms of loading times? requiring to touch all parts to fully load the app?

I think a feature like this sees best use in short lived programs (where startup time is a disproportionate percentage of total run time) and programs where really fast startup is essential. There are plenty of places where I could imagine taking advantage of this in my code at work immediately, but I share your concern about unpredictability when libraries we use are also making use of it. It wouldn't be fun to have to dive into dependencies to see what needs to be touched to trigger lazy imports at the most convenient time. Unless I am misunderstanding and a normal import of a module means that all of its lazy imports also become non-lazy?

Used this, sigh of relief, thank you

this is the case indeed

5k pdfs a month for archival purposes, must be pdf, customers demand this

doesn't pandoc rely on some engine itself?

Yep, you need something like XeTeX in order to render the PDF.

Curious why that matters to you?

I mean everything has dependencies (some of the solutions elsewhere require Chrome and other common solutions require the JVM). At least Pandoc is GPL.

It matters because pandoc is not rendering the website to pdf, it converts the html to latex and then uses a latex engine to render the pdf.

Forgive me but I don’t understand why that matters to you and am trying to understand what the issue with Latex is.

Because lots of things work this way. For example compilers built on LLV uses an intermediate language and Python uses byte code.

I suspect some html to pdf tools go through postScript.

There are multiple ways to "depend", so if pandoc executes some external tool all of the work then might as well use that external tool directly. You will get more control over how the conversion happens, know for what search for when in trouble etc.

My understanding and experience is that Latex has a significant learning curve and Pandoc provides a more gentle front end.

Of course Latex gives you fine control to hand tune the engine…but that doesn’t seem like what the OP is looking for.

Sure, I don't mean that anyone would look at the Latex in between. I'm just saying that if tool x directly calls tool y to do the job then might as well use tool y directly.

Since hammers and nails are a common tool-workpiece example…consider the nail gun.

Theoretically you can drive nails with a 22 caliber blank cartridge without making the “call” through a nail gun. But you won’t finish laying shingles as quickly and easily…

Or to put it another way, there’s a reason assemblers are almost always better than machine code and compilers are almost always better than assemblers for the ends people care about.

I mean why use Latex at all when you could write your own typesetting language? Maybe because you are not a knuth.

You're confusing wrappers with alternatives. The comparison is more like if somebody published a script called html-to-pdf.sh which directly calls, e.g, chrome, would you want to use this script or use chrome directly? I would prefer the latter because (1) I would know what actually does the conversion, (2) I would know what to search for on the web should I need to tweak the output. This knowledge gives me more power as I know the actual converter. The wrapper script perhaps only helps with what the command line should be.