If this ships, it will change javascript forever 

we will eventually get there lol

Predictable and good

JavaScript is the new JavaScript

😮

I feel like a baby because I have used Promises from day 1 and do not know a world without it. But I can see why signals would be as impactful

Its okay ​@csy897

Yeah looking at old axios code in large apps is just... Mind-blowing honestly 😂

> "Like Promises replaced callback hell" Out of the frying pan and into the fire, e.g. async/await "two-color" function hell! 😢

@@gearboxworks to clarify, Promises are independent from async functions. But yeah, I feel you.

this

Right? "Signals" is confusing the hell out of me because this is nothing to do with signals.

It's a signal because it's a two way thing. Push dirty flags towards consumers when root data changes, and push recompute requests towards the root when the new data is needed for consumption (and also do no recompute when inputs don't change). So it's a lazy, two-way observer pattern.

@@W1ngSMC exactly

currently playing with LegendApp state and even syntax for basic stuff is almost identical

At least JS and TS ship once in a while

And that’s the point: they want a minimal base that provides the most useful parts without forcing laziness as default.

Not just Haskell, seems people are starting to understand that declarative is future (and I'm 100% sure imperative will die, as is spaghetti nonsense in long run), so instead of fully committing some salad gets invented. Which is still progress, but still. As shown by polyfill it was doable all along :) I guess just "environment" (read people) need to grow.

@@morphles isn’t that what the prolog people used to say?

@@ArneBab Only in a couple of days later, they need to wait for their proof of concept to finish evaluating.

Seems like it

No, it’s like React state (ref, memo, etc…) but in javascript itself.

@@fullfungo no

bro redux selectors predate vue

@@klausburgersten yeah they probably do... whatever that is

Dude bro

@@vincentv8991 dude

Lol

And some edge case performance optimizations, and framework interoperability... Probably

I think 15 years from now best features of every framework will be native and we'll just write vanilla JS.

State management is indeed core and central to every framework, but there's much more to it.

JS, and by extension TS, are the fastest moving languages in history. Love it or hate it, JS is the social programming language. That gives it the highest adoption, thus the most iterations/collaborators, thus the highest likelihood of becoming ubiquitous to the point of absorbing all competition. See: AssemblyScript (TS->Assembly); Hermes Static (TS->C); Frameworks are no exception. Resistance is futile. All will be assimilated.

It all return to nothing...

Yea, _very_ disappointing to see how Theo glosses over the OG and state of the art works cause it just ain't give clickz.

Also can define computed get and *set* abstraction in Vue. Very useful when binding.

They use proxy objects to attain this functionality

Signals have been around for a long damn time, and are demonstrably good for performance already. The reason to get it in the language is that then the DOM can use it and the implementation can be even more performant. It would be super nice to be able to assign a function to a label and it Just Works™.

The most useful features have come from jQuery, which was used basically everywhere. Nowadays we have a bunch of frameworks with own set of features

@@saiv46exactly, signals are already in many frameworks and have proven their value. This just promotes it to the language level.

It looks like that's what they're doing, right?

WHat arer you, old? Have u seen all the blahblah.JS c0ntribootor nnicknames at allz?

the concept of computed is the same from Vue. As some one who works with Vue2 since 2019 I can say these people are way behind Vue and this nothing too fancy or to be excited about.

@@MrDragos360vue has done a terrible job at marketing. I had a job interview recently where a senior frontend dev told me their company moved from vue to react for WAIT FOR IT performance reasons 🤣

Evan you is also part of this proposal and he tweeted recently regarding this.

getting signals into js itself would help vue performance wise as well. Being able to share vue ref states with other js frameworks/apps is also nice. But yeah vue already has most (or all?) of this and it's one of the reasons why I use vue when I get the choice.

Right! Anyway subscribing to ko observables could cause cycling deps. I wonder how they resolve or at least protect us from it

Rob Eiserberg is the one who created DurandalJS a decade back, which extensively used knockoutJS for reactivity. Definitely got inspired.

This explanation actually clarified something about signals for me. Thanks.

He literally said that shortly after.

@@tvujtatata Yes it was in the article. It wouldn't have escaped you as well that I was talking about chat at a timestep in the video as well, right?

The main benefit is in effects though. The effect will be re-run only if its sources change. If your effect is a React component, that means it will be rerendered only when necessary, without rerendering its parent or child components.

??? I mean that is the point its not an event implementation you ask for an update manually this is exactly what you often do in all kinds of systems with lambdas or function references. In the end similar to lambdas it makes it extremely hard to find out where things are happening

You can do this in solid's signals too, through a couple of options, but it's a bit uglier IMHO.

It's untrack(() => ...) in Solid. Solid's signals are just two functions that you can call, not an object with methods like .get() .set()

@@reoseah Preact has untracked(() => ...) as well, but I haven't used it for basic state updates since its much more verbose

Something so convenient seems to go in the opposite direction to what the use of the subtle namespace is trying to imply.

Exactly, I'm also very fond of web components and use them a lot in a lot of projects. Also I've seen some libraries for React like the Mux Client SDK and LiveKit that use web components under the hood and simply wrap their components in connectors to easily distribute their components across React, Svelte and others without having to rewrite their entire product.

Ayyy solid!!

Maybe a intended pun

Really really close. They sound different in my head but I can see the source of confusion in non native speakers

I say “a sink” as uh sink and “async” as ay sink

But usually the context in which the two will be used will be disambiguating. It’s probably only ambiguous without context.

yeah i woulda preferred consumer and producer but i'd also just call tree-shaking dead code removal :shrug:

Exactly. Pretty much the same thing.

Having worked on a KnockoutJS project myself for many years (2014 - 2018), this was exactly my thought 😄

Knockout js also had since 2010..

I used CanJS and also its predecessor, JavaScript MVC. It's weird how we had all these great frameworks and they all disappeared and were replaced by React. Also, what happened to Polymer framework??? IMO, Polymer was superior to React but very few companies used it at the time. I guess at least now there is Lit... But you don't really even need a framework at all nowadays. Web Components is powerful stuff.

@@Remindor Vue is actually the most popular one that was inspired by KnockoutJs but the video doesn't mention that somehow.

@@ziad_jkhan​​⁠ … Vue is _explicitly_ called out at 13:15 as one of many frameworks that have provided input on the proposed spec.

@@Remindor WC’s are super cool. Lit does at least purportedly help take some of the boilerplate out of writing WC’s. I haven’t used it yet but considering experimenting with it.

🤓

Yes, this! Thank you

Do a find all references on the variable. It's trivial.

Sideeffects all over the place…

YUP YUP! The profiles of the proponents worry me... I don't see their future. I don't see the future of their work.

yep the rate this got adopted gave me pause. i did recently realize mithril.js has had a hacked-together unintentional construction of half of this (in the style of every program eventually growing a bug-riddled half-implementation of common lisp) since its first release 10 years ago (2014 march 17), so that makes me feel much more like it's truly on to something. (i'm also a former maintainer of mithril.js, so...)

You would be surprised by how much Signals have matured. This effort to standardize stems from the fact that all frameworks have derived pretty much the same Signals implementation independently, the push-pull tainted graph. They do differ on how effects run and other details and the proposal accounts for that.

And one point about interop: even if they all agree on a single base signal lib, you need a single instance of the lib running for it to work (since it relies on a single call stack context to track subscriptions). This is challenging as it requires npm/yark/pnpm trickery with peerDependencies, bundler configuration, and/or manual setup.

My argument rests on interop not being desired enough feature. Don’t think it is. Can’t see many reasons why it would be. If it were, it is something that community can solve without tc39 standardization. Additionally, signals can be adapted between implementation, even if there is a perf penalty. I doubt that cross-signal-implementation calls are frequent enough to manifest perf issues. As to other arguments I’ve encountered: - Perf gains are likely insignificant - Optimization opportunities are lacking - Signals being in DOM doesn’t achieve much. Maybe observability of attributes. Can be done with MutationObserver (I’ll give you that it isn’t a particularly nice API) Yea, it is doomer-like mentality and the “ooooh scare of change”, but maybe let’s not bloat JS even larger than it is. Look at where it has lead C++ to. But I guess either way, acceptance of the proposal won’t really affect me that much. I’ll gladly use JS signals if they are a part of library interface or they suit my needs (as opposed to reaching out for a 3rd party library). You have every right to be excited by this addition. I am just not. Not sure it sits right with me.

There is a whole lot of optimization opportunities here. Implementing stuff like this in V8 or another JS runtime will drastically improve performance when you start to natively optimize dependency graphs and things like (de)serialization.

@@yapetthe interop goes beyond frontend frameworks. Signals being a first-class citizen could replace every kind of set+subscribe interface. I find Promises to be a good parallel here. Assuming you have been in this space long enough, would you rather still be using Bluebird.js or Q today? Did you imagine what the ecosystem would have looked like with native Promises back then? Could you imagine a JS world without native Promises today?

Exactly, I always loved MobX, used it from first public versions

It works the same way as it has in VueJS since at least 7 years and it's surprisingly simple. You run the function in the initial setup, and each call to `get()` registers the signal with the function. So for example effect(() => `console.log(myvalue.get()))` would initially log the value, and the call to "get()" would setup this lambda function to rerun the next time any call to `myvalue.set()` is being made (more or less). When it reruns the function it erases the tracking and registers all the get()'s again, that's why things like if-conditions still work. However, there are ways to also set up effects without running them first, in which case you would need to provide the signals as dependencies just like in Reacts use_effect.

@@Luxalpa oh man that's clever 😄

lalo lite

yup, redux also uses it. when I roll some vanilla state management solution, I usually go with a proxy.

I did. I just use rxjs as state manager

how?

Rxjs is loaded with crap complexity, because it couldn't come up with smth js-native. Signals fixed that to some extent.

RXJS has everything it needs for the flexibility it requires for the complexity of the websites that use it. In most sites you will only use map, and mergeMap to transform the values inside of Observables, fairly easy ideas to grasp. But the core concept is very simple. Think of it like a Promise that can be triggered multiple times. It should have been added a long time ago, while leaving users/library creators to create operators for more complex uses.

RxJS is glitching by default, and that is terrible and leads to many bugs (at least in our production app it did), which are hard to debug and tedious to fix. Non-glitching signals are a *significant* improvement on Rx observables.

@@nUrnxvmhTEuU can you please tell us more about that "glitching"? I'm using RxJS for ~5years now and I had many problems with it... But EVERY time it was my mistake or missunderstoodment on some concepts/operators. But I must agree that debugging it is very hard.. And also the documentation is... you know. :D

And then marking object hierarchies dirty because one of one nested value. Perf goes crash!

Regular arrays would presumably only be compared referentially. There is another proposal for structural equality. It adds records (which are essentially immutable objects) and tuples (immutable arrays). Look up "JavaScript Records & Tuples Proposal" if you're interested.

dude I'm not the only one.

Just about every major advance in JS frameworks seems to be inspired by native frameworks...

No, it's innovation, dammit!!!!

@cocoscacao6102 That‘s irony, right? If so: :]

But Qt signals & slots aren't like this. They are literally just events and consumers. Without memoization, lazy evaluation, ... and all the good stuff detailed here.

@@W1ngSMC Singal/slot embodies the core idea behind JS signals: very precise, efficient, fast reactivity. The other things (memoization, lazy evaluation etc) can be implemented on top of that.

Exactly! I'm not too sure about this one

It's more efficient, and allows less JS to be shipped for frameworks that leverage their own implementation of signals.

Functions are not reactive though. I do see your point as passing a function around that wraps a variable will have access to that variable. The use case is passing a variable around and updating it. You want the original variable to update even when it is assigned to another object property or anywhere it is updated, up and down the chain. You don't get that unless you only pass the original. Essentially, as soon as you assign to the value, it loses its reference or copy on write. With this, it doesn't matter where the update happens, it would update anywhere the variable is used. Granted this is technically true with any object.

I agree. It solves a problem that frameworks added, and it can be solved by existing features. This only needs to be a package.

Because implementing these primitives on a browser level opens up room for allot of runtime optimizations, its very likely every state framework will use these primitives if they are implemented well, because it would save a ton of performance

const foo = { bar: 'baz' }; foo['bar'] = 'foobar'; To me it makes as much sense as this. foo never changes here as it always points to the same reference in memory. A signal might point to an address in memory and the value at that address can change constantly without ever changing the address itself.

no, it's pretty simple, you just use an object or a tuple (array?) I guess. Been a while since I used JavaScript but in Rust I just use Tuples and Structs as the parameter type, it's just like having multiple parameters.

@@Luxalpa You mean a map of arrays representing the provided arguments? That doesn't work because Array isn't a value type, so they'll never compare as equal and you'll never be able to find anything in the map.

There are so many state management libs that use MVC, I'm curious why he frowns upon it but it is funny to see him react to things he feels averse to. I feel like the deeper you get into building stuff for a longer period of time, you develop your own style and aversions from badly written or very unperforment or buggy code. Kind of a PTSD

not doing MVC is the biggest reason JS FE (especially React but not only React) is such a hellscape. Signals won't fix anything, until this attitude changes.

Theo gives me big ego junior superstar vibes. I wouldn't be surprised if he had a lot of friction with his seniors at his previous jobs, and that a lot of his naive takes on certain concepts like MVC and separation of concerns is him projecting his frustrations with past colleagues forcing him to adhere to concepts he didn't fully understand at the time, and due to his large ego he's written them off as pointless, instead of learning their values. I think he's been stuck in that mindset ever since. I've seen this personality countless times, and I've been there too when I was younger.

@@csy897 can u provide MVC library, if the new frontend junior never learn mvc. They might only learn mvc over server side language through traditional university route. and the new frontend route is react. Basically it is what happen on me. Love write server side, but the most favourite of me is pure PWA, it scratch my head every project, i pick different style depend complexity

@@kasper_573 He also feels like he's got a big ego from doing actual valuable work. I believe that if he meets a problem that is better solved with one of the patterns he doesn't like, I'm sure he's the type that will cave. It's only human to have likes and dislikes, and therefore it is important to surround ourselves with different ideas. As long as we collectively are able to consider what is best for the application we're handling, I think our differences in inclination are what makes app dev fun.

There a lot of people much smarter and more accomplished than you (and me!) working on this. Not saying that automatically has merit, but we could at least see what they come up with before trying to dismiss it.

@@PraiseYeezus This doesn't help as an argument because one could have said that about observables at that time, too.

@@_nikeee "wait and see" isn't an argument for or against observables or signals or anything else. it's an argument against your dismissive statement.

Observables was shit. The current mutation observer is not great. If the implementation is like RxJS, then it could be good.

The problem is that it didn't solve the issue that programmers were having. They had an idea for the use case and it was great for that use case but it was terrible for what programmers wanted to use them for.

That is good news. I would use the hell out of RxJS if it was native.

Only another 9 years to go.

Sounds quite bad. I remember working with rxjs in angular 2-4 and it was a lot of unnecessary and complex boilerplate. Happy that nobody tried to force rxjs into react.

@@HyuLilium jQuery lit the fire for browsers to support querySelector API. RxJS as a concept with streaming is awesome. The Proxy object was neat in what it allowed RxJS and other libraries to do with watching updates. The ability that some languages have with being able to watch and trigger updates when values change is intriguing and could be useful. It is crazy with how much JS is event-driven that something like RxJS isn't just native.

@@HyuLilium what boilerplate?

Doubled is recomputed every time you call it even when it doesn't need to

A closure isn't reactive. Yes, if you reevaluate the function you'll get the new result, but there's no mechanism to tell that you _should_ reeval because x changed. And there's no automatic memoization, avoiding the recompute when it isn't needed (which wouldn't be an issue in your example but would be massive if the computation involved i/o, for example).

@@PeteC62 well we can implement caching if the computation gets expensive.

​@@pixelsam123 Instead of recomputing doubled, you walk the graph for dirty/clean and then decide whether to recompute. There is a reason they like to use doubling a counter as an example. It's because the complexity factor goes up really fast when you try to use signals beyond very simple cases.

I always felt model-view arch to make more sense in qt, yet it was always pain to work with in practice... signals ftw

That is exactly what SolidJS is doing, check it out!

Check out legend-state

He is a part of the proposal lol, he has been contributing a lot

@@devagr His name is not even in the list of contributors.