Ryan Carniato

Maybe we've had self cancelling async in Solid for 6 years which while not entangling would have the same behavior on hitting the same button or input over and over. And I haven't had any issues/complaints about that to date.

Our async primitive is already self cancelling. So even without entanglement source outpace output could be an issue. But entanglement ensures consistency especially where async mutations are involved and generalizes optimistic state mechanism in the core reactivity.

End user actions usually will end at some point. Especially if things aren't updating.

So it has be some sort of event based system whose updates outpace the async. But the events need to trigger downstream async, and not just be async themselves.

Yeah interesting thought experiment.

Not sure. I know React has a timeout. I think having more than one in flight, ie graph isolation helps a bit. But if you hit the same part of the graph over and over it would wait indefinitely. Where would this catch us? Effect loop would be bad, but it would be a loop regardless even if not async.

Designing Async-First Signals YouTube video by Ryan Carniato

The stream is back tomorrow as I dig into what I've been working on in the world of Async & Signals.

www.youtube.com/live/ori9xZh...

For anyone interested. I do have some Svelte versions of the Demos to contrast the behavior differences. Svelte has parallelism (unlike React) but it doesn't entangle. Ie.. click quickly.

Async Holding:
svelte.dev/playground/7...
Parallel Async:
svelte.dev/playground/9...

Anyone notice what is missing?

A big nod goes to both React and Svelte for inspiring this work. I've managed to marry the benefits of both approaches to async directly into the Signals themselves. Minimal API surface, Graph-based Parallelism, Consistency Entanglement.

I also did the async holding example:
playground.solidjs.com/anonymous/07...
And the parallel async example:
playground.solidjs.com/anonymous/97...

here is something that feels so powerful when behavior is baked into the reactivity, rather than compilers or framework. I've remade a few demos trying out the reactivity with manual DOM updates to test it out, starting with Ryan Florence's Select Example
playground.solidjs.com/anonymous/85...

On the microtask queue, or when you manually call it yourself in the event handler (like React's `flushSync`). None of this impacts the Reactive graph which is always seeing the latest value. Just stuff outside the system like event handlers, or effect callbacks.

Thoughts on an approach to async in SolidJS that requires no wrappers, compilers, or coloration, non-blocking render, but it requires `setSignal`(& derived) to stay in the past until flush?

1️⃣ Yes, seems good
2️⃣ Yes, used to it
3️⃣ No, React is the worst
4️⃣ No, async isn't worth it

📊 Show results

I've noticed this trend is just about being a year or 2 behind but the later you come the harder it is to be at the same place at the same time milestones. Like Vue 3 years in looked a lot different than Svelte, and Svelte 3 years in looked a lot different than Solid 3 years in etc..

Yeah it continues down the line. I guess it's part of the inverse introduction issue. Like the later the framework is introduced the harder to get any sort of traction. Like Qwik and Ripple have it worse than us (if not for their creators having built other frameworks).

Like we wrote our own deployment setup, then switched to Vinxi so we could universalize server functions. This inspired Vite to change in v6, and now there are server functions/component support core to it, so other frameworks can add those features. Now we are switching off Vinxi to pure Vite.

I was just curious. I do think with the number of times we've changed the internals there is a perception. It's just funny because we did so to support our goals. By demonstrating that caused change in the actual ecosystem that other tools can leverage when they later leverage the same features.

GitHub - webcomponents-cg/community-protocols: Cross-component coordination protocols Cross-component coordination protocols. Contribute to webcomponents-cg/community-protocols development by creating an account on GitHub.

This is what I was refering to: github.com/webcomponent...

Yeah I am not sure. I know what you are talking about. Might be in the name. Like doesn't stick with people. We haven't put anything into marketing, but I can't imagine Svelte has done much. But when you look at downloads on npm, I'd say more people knew about Svelte at same thresholds.

Is there something you feel lacking in SolidStart? By my best estimate other frameworks keep grabbing up our features.

My writeups on the idea so far:

Designing Async First Framework
hackmd.io/@0u1u3zEAQAO...

Different Take on Async/Concurrency?
hackmd.io/@0u1u3zEAQAO...

Deferred Disposal Reactivity
hackmd.io/@0u1u3zEAQAO...

Solid2 Experiments Tabs - StackBlitz Run Solid2 Experiments created by Ryansolid on StackBlitz

Every 5 seconds we navigate to the next page, loading more data. The counter continues to log from the previous page.

This is a non-visual version of this example when switching between "uno" and "dos". What's missing is no explicit Transitions.

stackblitz.com/edit/github-...

No compiler. No transition wrapper. Just concurrency and async by default in a few hundred LoC. This is not the user's API. It is a proof of concept built on @milomg.bsky.social's R3, a new more performant approach to Signals, that propagate in a single pass while maintaining guarantees.

Alright progress. I imagine most won't understand what you are seeing. I had a crazy idea a week ago that all the ideas we have about async could be wrapped into the native behavior of a runtime reactive system. So I dropped what I was doing to test.

playground.solidjs.com/anonymous/c1...

Two really good examples are in React:

Splitting tracking/deps from their side effect.
Not apply the value immediately after `setState`

I've always been able to argue correctness for these, but chose differently for convenience. But what happens when ambition grows and convenience turns liability.

The worst part of API design is when the answer is the one your users will hate. They will never thank you for it. They will misunderstand it until the end of time. But there is some comfort in them never knowing the pain they may have faced.

What's the difference between Knockout.js and Rx.js? Does anyone know the differences between RxJs and Knockout? To me on the surface they seem to be trying to solve the same problem, to build an event driven UI. But someone who has had experience ...

I think implicit derivation is actually a lot easier here. If you ignore the syntax it's a bunch of assignment statements. That plays to comfort with procedural things. Old Steve Sanderson quote (Knockout.js): stackoverflow.com/a/6797091

That's part of the debate. Implicit obvservation isn't a problem in React and yet that is what everyone complains about. Ironically libraries with implicit deps in effects rarely hear complaints. That aside, this debate matters a lot less when people aren't overusing effects.

Explicit vs implicit deps are a debate. But most people debating it are doing so for superficial reasons. The real problem is what you do with the effects. Writing a Signal in createEffect is only narrowly better than what happens in React and probably should be avoided most of the time.

Yeah I shouldn't say no talk pre-hooks. This was like the 2016-17 conversation. Around the time React Native came out. People were hitting performance issues and coming up with solutions. Hooks were when suddenly it was everyone's consideration as a baseline.

Yes, but why do we reach for it to write to state when we could derive? I think about this a lot. React doesnt want you to write to a bunch of state in effects, nor does any framework. I think it starts with how we set up our state in the first place.

That is fair. Probably less React's API at the time but the language we used to describe UI. Signals back then still had computed values, but pre-hooks, no one was talking about memoization. That's the point at which dependencies become obvious. No one was paying attention to their messy state.