Unforgettable three days hanging out with so many new friends. I cannot believe I got to meet folks from Vue, Vite, Nuxt, Solid, Qwik and Svelte all in one place within such a short time. Everyone was so welcoming. Can't wait to see y'all again soon!
Just got back from
@devworld_conf
in Amsterdam. I am very grateful for the opportunity to talk about Web Development at Google with
@hdjirdeh
and
@mgechev
. Thanks
@josgerards88
and others for organizing such a great conference!
@angular
@tbondwilkinson
You can follow along as the code lands here: . It is exciting to see the code that powers making its way into Angular to deliver new capabilities to the framework.
@hernan_yadiel
@mgechev
As long as data fetching is a side-effect of rendering, composability is limited due to waterfalls. Too many suspense boundaries can also result in popcorn UI. I think declarative data fetching ("loader" style APIs) will likely keep getting better.
@droidpac96702
There's always work to bring various low level APIs together. Note how the signals proposal does not include an effect API. Effects are often deeply integrated with UI updates that are highly framework dependent.
@jherr
Thank you for covering Signals on your channel Jack!
If you are interested in Signals join us on discord here: . We are trying to discover use cases, discuss the API and showcase work like this.
@nahum_zsilva
@sarah_edo
Not related at all. Wiz and Angular are two separate Web frameworks (like React and Svelte are different frameworks). If you are looking for a metaframework for Angular check out
@analogjs
. That's more like nextjs or nuxt.
@tomasz_ducin
this sounds like "stores". this requirement has emerged among some early adopters of Angular Signals at Google. is there any existing implementation of stores in the open siurce that you like?
@dmitriid
There is no silver bullet for all performance problems. In fact, even if you have a framework that blows others away on some benchmark, that is insufficient. The real challenge is to maintain performance over multiple years, across 100s of developers and 1000s of features. It is…
@RyanCarniato
@PatrickJS__
@TkDodo
I think there might be an opportunity here to develop something framework agnostic. this is a primitive, like signals.
@bentonnnnnn
@dmitriid
we added a few things over the last two years. "wiz client components" I guess? a TSX based authoring format with signals for declarative UI updates.
signals stay fast due to fine grained updates and since the memoization burden is lower. you only need to worry about…
@Dominus_Kelvin
@angular
ship less JavaScript isn't the primary goal. the goal is to ship JavaScript responsibly. ship as much as you need!
systemic code-splitting, multiple entry points on the same page, be intentional about when the JavaScript is loaded, when it is executed, break up long tasks, etc.…
@RyanCarniato
@PatrickJS__
@TkDodo
how does solid start handle async bubbling when mixing PE and event replay? does it recreate async bubbling by providing global delegation for all event handlers?
@dmitriid
Thank you for attempting to keep us honset Dmitrii. I'm going to try a good faith answer here. If you see this part () of the keynote you will notice Chris is talking about UI update performance (e.g. 60 fps).
@dmitriid
Lighthouse is important. But Signals (fine grained updates) shine when it comes to UI updates. Typically, users use a product like YouTube for long periods of time. For such businesses on-going performance (i.e. UI update performance) matters more than initial load latency.
@_developit
@mhevery
@smearthelove
@builderio
To achieve full resumability you have to serialize the signal graph itself. Without the graph you need a hydration pass to get things going. This might not be a big deal if you have fine grained islands. But a deeply resumable framework might not accept the hydration requirement
@DanielGlejzner
maybe signals can find a place if somehow the signals themselves aren't directly exposed to the developer. for example, a compiler might be able to generate code that uses signals for auto-tracking.
or maybe not, I'm not a react dev 🫣
@Jean__Meche
@Enea_Jahollari
What if LazyServiceA injects ServiceB which in turn inject LazyServiceC. Now when ComponentFoo injects LazyServiceA it'll take two round trips to instantiate. A deeper compiler integration might be able to avoid this.
@DanielGlejzner
the programming model of react is simpler for developers because they do not need to distinguish b/w reactive and non-reactive props.
for a component author, all props are non-reactive. if they do change, throw everything away and make a new component.
@modderme123
@pkozlowski_os
Dynamic edges should be dashed lines with a color or thickness representing whether it is "active". This visualization is great! Adding colors to demonstrate the tristate push-pull-push and animating will finish the TikTok that explains Signals (Signals in 100s?)
@fireship_dev
:)
@pkozlowski_os
@modderme123
@fireship_dev
some edges are provably compile time constant. could be useful for compiler-based optimizations like topo sorts. a library runtime should support that so compilers (or super users) can take advantage of it.
@BHolmesDev
😋yum! love recipies that optimize for time to "first bite".
how can the stack be interactive on first render? dropping events because hydration is beind a network roundtrip is yuck.
@mipsytipsy
a dark launch -
"Dark launching can also enable parallel running of a re-implemented feature. The old and new code can both be called and their results checked to see if there are changes with the new algorithm, but only one answer returned to the…
@DanielGlejzner
this mental model is valuable and worth preserving. if devs are writing signals - suddenly signals can be passed as props and that spoils the update story.
@devagrawal09
this is the one! for the best devex it should be implemented by monkey patching browser APIs like createElement, setAttribute and appendChild. We shall call it "DOMes.js". developers simply keep making DOM and Angular automatically turns it into VDOM 🤯
@nullvoxpopuli
@sarah_edo
YouTube is adopting Wiz. APIs like rendering, event binding & component lifecycle are currently provided by Wiz. Wiz and Angular share the reactivity library and thus YouTube uses Angular signals. Over time we expect the level of code sharing b/w the fwks to increase.
@mhevery
Ah, the data deserialization logic is not application specific if Qwik ships a single generic serializer/deserializer. Like always using JSON. Is that what happens?
@dan_abramov
Wiz does this. Components declare data dependencies. The framework kicks off all data fetches before starting to render. As the static bits at the start of the page are rendered they are streamed to the browser. Keeps going till templates deref a future that hasn't settled yet.
@BenLesh
RPC abstractions have provided Zod-like type-safety since 2016. The three things that make it great are (1) Type Safe (2) Asynchronous APIs (3) Interceptors.
#3
is a gold mine over the years. JSON vS gRPC is a false choice. The gRPC spec doesn't preclude using JSON serialization.