wngr

Kudos to the n0 team shipping 1.0! Truly exciting, stellar technical approach and execution; I hope you guys will get sufficient commercial traction to keep going!

It’s not nested, that’s the thing.

What does that mean in the context of a Merkle tree?!

Apart from small software studios with non-SaaS business models, there is just no viable local-first (offline-first with infinitely delayed sync) application category, in the consumer space. Consider military applications with heterogenous and constraint networks, where assets might need to coordinate p2p under adversarial jamming. There might be applications, where AP (choosing Availability and Partion Tolerance, cf CAP theorem) makes sense.

That’s a great, nuanced view! Thanks for sharing!

One might even say PATHETIC.

I remember Actyx being a rust-libp2p user, but I wasn't aware that they failed. Do you have more info? How and why? It would be great if we could learn from them.

They (we?) unfortunately never found product-market-fit. Actyx targeted the SME factory space with a p2p application platform. Turns out that developers in general don’t want to deal with the additional complexities of anything lesser than strong consistency, especially if they don’t fully drank the distribute-everything kool-aid. And SMEs don’t really bother either.

Philosophically decentralization is the right thing to do, but I’m thinking more and more that federation might actually be the compromise in the long run, at least for consumer apps. The only valid use cases for p2p edge devices with loose connectivity are in military applications.

Great idea combining batman with libp2p! You guys have the heart in the right place :-).

Currently, your project seems to be an opinionated wrapper ontop of libp2p. For this to become a proper distributed toolkit you lack an abstraction to for apps to collaborate over shared state (incl. convergence after partition). Come up with a good abstraction for that, and make it work p2p (e.g. delta state based CRDTs, or op-based CRDTs based on a replicated log; event sourcing ..). Tangentially related, a consensus abstraction might also be handy for some applications.

Also check out [iroh](https://github.com/n0-computer/iroh) as a potential awesome replacement for p2p; as well as [Actyx](https://github.com/Actyx/Actyx) as an inspiration of similar (sadly failed) project using rust-libp2p.

Oh, and you might want to give your docs a grammar review.

Kudos for showing!

I totally agree with you, but those shows are not what parent means.

Also take a look at iroh [0]. It doesn't come with the bloat of ipfs, provides robust core building blocks. They really figured out NAT traversal.

[0] https://github.com/n0-computer/iroh

I was really impressed when I clicked the reload button -- inspiring attention to detail! How did you create those?

Issues have been deleted in the meantime ..

There is quite a bit German community there incl doctors, lawyers etc. the big hospitals are also okay, although the local youth is fleeing the island.

To understand the difference between a manual and a highly industrialised process doesn’t matter here. It’s about the underlying principles that define how things work.

They might not know how to navigate an iPhone or TikTok, but those are not foundational skills.

Of course they will catch up, if they’re motivated at some point to do so. And the others will lose it as soon as they stop using it.

<https://archive.ph/2022.07.08-135829/https://www.ft.com/cont...>

7. Baby-led Weaning was amazing for us. No purees. No special "baby food". At six months, our kid ate with us on the table, same food as us. Really helps their independence, easier on groceries, and helps to bond eating the same thing together.

Totally! Only limiting factor are the teeth.

Survival rate is probably up compared to 1960.

Would appreciate an anecdote.

Nice to see more competition in that space! I'm a long term happy user of https://unraid.net/, which I can very much recommend.

Neat. Nice write-up!

Yes, it's pretty decent for that.

(2020)

+1 for current Garmin models. They finally fulfill the requirements my former Pebble models set.

Somewhat off topic: is there another English term for Zugwang?

Nice project, although pretty opinionated. But I guess you have to do that when targeting the crazy browser environment with all its weird quirks (at least for non-web devs)..

Somewhat related is a library I've been working on to generate an ffi between Rust and js code: https://github.com/cloudpeers/ffi-gen

Also I really like your universal_thread abstraction, hiding the whole web worker mess. I did a similar thing here: https://github.com/wngr/wasm-futures-executor

Great execution of the app! When signing up on Android, the mail sent with the notification code is in (presumably) Mandarin and not the locale used in the signup screen.

By the way, I built something similar (?): A Rust library that mimics the API of the `futures-executor` crate, but each worker thread is a single WebWorker.

https://github.com/wngr/wasm-futures-executor

Nice. Do you also support SharedArrayBuffers or does everything need to be serializable that is sent to/from WebWorkers?