I'd love to see more articles on the subject or even a proper book of "gems / design patterns in ECS".
It's also interesting how different libraries take different approaches that have far-reaching consequences... for example, "how to detect changed components" isn't really fundamental to the core concept of an ECS, but it's an essential ingredient and they all have different ways of doing that (FlaggedStorage, events, ...?)
Fwiw in the work-in-progress todo example linked above - what I did so far for that particular problem was add a "Dirty" component. In Shipyard, adding/removing components is cheap so using these "Tag Components" to create a de-facto event mechanism is totally fine. Don't have to depend on an actual event or notification system for that (but this approach would not be as good in archetype-based ECS's since adding/removing components is more expensive there, and it could explode into needing lots of separate Dirty components, depending on the application)
Sometime soon (within this week) I want to try and use signals as the component data.. then when it changes, anything that is interested can be notified that way. Not sure yet if it'll work out the way I want - but if it does, imho that's kinda cool and would feel pretty elegant since it means a totally different part of the stack, like dom renderer (via dominator) can just listen to signals and not care how they're triggered.
On that note - this problem of tying the ECS to other things (like DOM tree or a separate physics system or a renderer) is something that could also use some articles and/or books
All in all it feels like early days for ECS actually... I guess it's technically been around for a long time, but with Unity's recent shift and the mantra of "composition over inheritance" becoming more and more popular for web... feels like it's just starting to pick up steam outside of the game studio world. Or maybe I've just not been paying attention enough, hehe.
For Rust in particular I think it can also make things a lot easier since it lets you pass around component data by reference, even with multithreading, without worrying about lifetime issues. That's a pretty big win too imho.