Future of Frontend Frameworks Fireside Chat

Rate this content
Bookmark

FAQ

The main topic discussed at the fireside chat was the concept of signals in various web frameworks and their impact on the ecosystem.

Signals are significant in web frameworks because they help with server-side rendering hydration, resumability, and provide insights into tooling. They allow developers to know the data flow within applications, making state updates more predictable and manageable.

The speakers advised choosing a web framework based on the specific needs of the project, job market demands, and personal preferences. They emphasized the importance of community support, documentation, and the ability to meet the project's goals.

The future of front-end frameworks includes standardization of principles, reducing the amount of JavaScript sent to the browser, and improving developer experience (DX). The speakers are excited about the ongoing explorations and innovations in the field.

Challenges in adopting new web frameworks include the learning curve associated with new syntax and concepts, the need to balance performance benefits with ease of use, and the complexity of maintaining and integrating different parts of the tech stack.

Standardization can benefit the web development community by making it easier for developers to switch between frameworks, reducing the learning curve for new developers, and allowing for more reusable components and shared practices across different frameworks.

The speakers generally believe that while standardization of principles behind frameworks is beneficial, merging multiple frameworks into one is unlikely due to the unique needs and vibes of different frameworks. Each framework has its own strengths and focus areas.

Old concepts such as server-rendered web pages and multi-page applications (MPAs) are making a comeback. These concepts are being revisited with modern technology to address current performance and scalability challenges.

The speakers at the fireside chat were Ryan Carniato, the creator of Sava.js; Minko Getsev, the product lead for Angular; Fred K. Schott, the co-creator of Astro; Akanksha Doshi, one of the core maintainers; and Tim Neutkens, the co-creator of Next.js.

The adoption of signals in web frameworks is expected to continue growing, with many major and minor frameworks already incorporating them. This trend is likely to lead to standardized practices and improved performance across different frameworks.

Fred K. Schott
Fred K. Schott
Minko Gechev
Minko Gechev
Ryan Carniato
Ryan Carniato
Daniel Afonso
Daniel Afonso
Aakansha Doshi
Aakansha Doshi
Tim Neutkens
Tim Neutkens
28 min
14 Jun, 2024

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Signals are being adopted by popular frameworks, enabling code reuse and improved tooling. While merging between frameworks is unlikely, they are learning from each other and adopting shared practices. It is important to embrace the diversity of frameworks and libraries. Instead of merging, focus on standardizing the principles behind frameworks. Consider tradeoffs and benefits when choosing a framework, and explore different technologies to learn new ideas.

1. Part 1: Introduction and Signals

Short description:

Thank you for being here. This has been an amazing day so far. We're going to have one amazing fireside. Can we get some fire here? Let's call our speakers one by one and give them a big applause. Starting with Ryan Carniato, the creator of Sava.js. Continuing with Minko Getsev, the product lead for Angular. Next is Fred K. Schott, the co-creator of Astro. Then we have Akanksha Doshi, one of the core maintainers. And finally, Tim Neutkens, co-creator of Next.js. Let's start the discussion with signals. Most frameworks are now using signals, and we expect this trend to continue. Signals allow us to remove unnecessary complexity and provide benefits like server-side rendering hydration, resumability, and improved tooling.

Thank you for being here. This has been an amazing day so far. And we still are going to have one amazing fireside. I said the word fireside, but I don't see any fire around here. Can we get some fire somehow here? Okay. An applause for the fire! Every fireside needs something like that.

So now I'm just going to call by the order that we have here, our speakers, and they're going to go one by one, but I'm going to ask you as I'm introducing them for you to give a big, big applause for each one of them, and starting with the first one on this side, which some of you already saw on the stage today, very likely. So give it up for Ryan Carniato, the creator of Sava.js. Okay. Keep it going, because now we're going to invite the product lead for Angular, Minko Getsev. Continuing with our next panelist, the co-creator of Astro, Fred K. Schott. Come on, let's go. We're still going on the flow, because our next panelist, she's one of the core maintainers, right? And we're going to invite Akanksha Doshi. Come on, applause, everyone! Energy! We need to keep this discussion alive. And last but not least, so this person you might know from the panel before earlier today, but he's also the co-creator of Next.js. So let's welcome Tim Neutkens!

Okay, and now I'm going to take my position on this chair. Let's get this discussion going. So we're going to start with one topic that Ryan already has on his shirt, I guess, which is signals. As we have been getting aware of, most frameworks have been getting all on signals lately. How do you all predict that signals will grow and keep impacting the ecosystem? Who wants to go first? Can we start with Ryan? Because he's got signals! RYAN NEUKOMPTON Yeah, okay, sure. I mean, it's funny, you think I would be able to predict these things, but I honestly didn't see us getting to where we are today where most of the major frameworks and some less major frameworks are using signals. I expect that trend to continue. The thing about signals is it's not about adding signals and suddenly getting these benefits. It's what you can take away. And we're seeing that across a large part of the ecosystem, adoption by many frameworks, some which have here with us some panel, and just simply seeing more benefits we can get from having data flow known to the application, basically. This applies in lots of ways. It solves server-side rendering hydration, things like resumability. It honestly will give us incredible insights into tooling. Wouldn't it be great if you could open up your VS Code and basically when you go to update some state, it will tell you every part of your app that can update.

2. Part 2: Adoption and Future of Signals

Short description:

Signals are now being used by popular frameworks and libraries, enabling code reuse and improved tooling. While adoption may require a learning curve and changes in coding practices, the future of signals is promising.

We know this simply because of the way signals wire up. So it's very exciting and even more exciting now because, you know, what might have started with small niche groups are now seeing, I don't know, thousands of developers now being able to use signals which is very exciting from my perspective. Microphone test? You can talk into my cheek. There you go. Let's try. All right. I have two microphones.

Based on everything that Ryan said, definitely they're going to help a lot with tooling, and in Angular we're really interested in using signals for partial hydration because we are aware of the data flow. We're chatting with Evan Yu before Jazz Nation like two days ago, and it's really exciting how signals can also enable code reuse across frameworks. Imagine building business logic or like some kind of hooks in one framework and being able to reuse them across all the frameworks in case signals become part of the JavaScript standard where they're hitting right now. I got nothing to add. It's working.

Okay. So I think, yeah, I mean, it's definitely true that now signals like apart from React probably all other popular frameworks and libraries are using the concept of signals, not directly, but still they are using the concept of signals. And the concept of signals I think has been there for long. I think KnockoutJS probably was ten years back, 2010 I think it came out, and they had they were probably the first one to introduce the concept of signals. That's what I read in the proposal. So the concept has been there for so long.

Now we are trying to standardize it so that there are different libraries, but under the hood sort of they use the same concept. And that's where I think the frameworks are slowly adopting it. Probably for React maybe if not using the signals directly because the way it works with the virtual DOM, but maybe it may combine with some state management library like recoil which is also using the concept of signals somewhat. So yeah, maybe we will reach a stage where all the libraries and frameworks will be able to utilize the performance improvement of signals which signals is giving you. At the same time, the way you write code when using signals is something which we are not used to. That is a concern as well at the same time. We have been writing the code for years. And probably we might be a little reluctant to, hey, now I have to change the way I'm passing the props. I have to use those braces to write the code. So probably that is where the learning curve will also come. So that is like a trade-off I would say. But yeah, the future of signals I think is really bright.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

A Guide to React Rendering Behavior
React Advanced 2022React Advanced 2022
25 min
A Guide to React Rendering Behavior
Top Content
This transcription provides a brief guide to React rendering behavior. It explains the process of rendering, comparing new and old elements, and the importance of pure rendering without side effects. It also covers topics such as batching and double rendering, optimizing rendering and using context and Redux in React. Overall, it offers valuable insights for developers looking to understand and optimize React rendering.
Building Better Websites with Remix
React Summit Remote Edition 2021React Summit Remote Edition 2021
33 min
Building Better Websites with Remix
Top Content
Remix is a web framework built on React Router that focuses on web fundamentals, accessibility, performance, and flexibility. It delivers real HTML and SEO benefits, and allows for automatic updating of meta tags and styles. It provides features like login functionality, session management, and error handling. Remix is a server-rendered framework that can enhance sites with JavaScript but doesn't require it for basic functionality. It aims to create quality HTML-driven documents and is flexible for use with different web technologies and stacks.
Scaling Up with Remix and Micro Frontends
Remix Conf Europe 2022Remix Conf Europe 2022
23 min
Scaling Up with Remix and Micro Frontends
Top Content
This talk discusses the usage of Microfrontends in Remix and introduces the Tiny Frontend library. Kazoo, a used car buying platform, follows a domain-driven design approach and encountered issues with granular slicing. Tiny Frontend aims to solve the slicing problem and promotes type safety and compatibility of shared dependencies. The speaker demonstrates how Tiny Frontend works with server-side rendering and how Remix can consume and update components without redeploying the app. The talk also explores the usage of micro frontends and the future support for Webpack Module Federation in Remix.
React Compiler - Understanding Idiomatic React (React Forget)
React Advanced 2023React Advanced 2023
33 min
React Compiler - Understanding Idiomatic React (React Forget)
Top Content
Watch video: React Compiler - Understanding Idiomatic React (React Forget)
Joe Savona
Mofei Zhang
2 authors
The Talk discusses React Forget, a compiler built at Meta that aims to optimize client-side React development. It explores the use of memoization to improve performance and the vision of Forget to automatically determine dependencies at build time. Forget is named with an F-word pun and has the potential to optimize server builds and enable dead code elimination. The team plans to make Forget open-source and is focused on ensuring its quality before release.
Using useEffect Effectively
React Advanced 2022React Advanced 2022
30 min
Using useEffect Effectively
Top Content
Today's Talk explores the use of the useEffect hook in React development, covering topics such as fetching data, handling race conditions and cleanup, and optimizing performance. It also discusses the correct use of useEffect in React 18, the distinction between Activity Effects and Action Effects, and the potential misuse of useEffect. The Talk highlights the benefits of using useQuery or SWR for data fetching, the problems with using useEffect for initializing global singletons, and the use of state machines for handling effects. The speaker also recommends exploring the beta React docs and using tools like the stately.ai editor for visualizing state machines.
Speeding Up Your React App With Less JavaScript
React Summit 2023React Summit 2023
32 min
Speeding Up Your React App With Less JavaScript
Top Content
Watch video: Speeding Up Your React App With Less JavaScript
Mishko, the creator of Angular and AngularJS, discusses the challenges of website performance and JavaScript hydration. He explains the differences between client-side and server-side rendering and introduces Quik as a solution for efficient component hydration. Mishko demonstrates examples of state management and intercommunication using Quik. He highlights the performance benefits of using Quik with React and emphasizes the importance of reducing JavaScript size for better performance. Finally, he mentions the use of QUIC in both MPA and SPA applications for improved startup performance.

Workshops on related topic

React Performance Debugging Masterclass
React Summit 2023React Summit 2023
170 min
React Performance Debugging Masterclass
Top Content
Featured WorkshopFree
Ivan Akulov
Ivan Akulov
Ivan’s first attempts at performance debugging were chaotic. He would see a slow interaction, try a random optimization, see that it didn't help, and keep trying other optimizations until he found the right one (or gave up).
Back then, Ivan didn’t know how to use performance devtools well. He would do a recording in Chrome DevTools or React Profiler, poke around it, try clicking random things, and then close it in frustration a few minutes later. Now, Ivan knows exactly where and what to look for. And in this workshop, Ivan will teach you that too.
Here’s how this is going to work. We’ll take a slow app → debug it (using tools like Chrome DevTools, React Profiler, and why-did-you-render) → pinpoint the bottleneck → and then repeat, several times more. We won’t talk about the solutions (in 90% of the cases, it’s just the ol’ regular useMemo() or memo()). But we’ll talk about everything that comes before – and learn how to analyze any React performance problem, step by step.
(Note: This workshop is best suited for engineers who are already familiar with how useMemo() and memo() work – but want to get better at using the performance tools around React. Also, we’ll be covering interaction performance, not load speed, so you won’t hear a word about Lighthouse 🤐)
Concurrent Rendering Adventures in React 18
React Advanced 2021React Advanced 2021
132 min
Concurrent Rendering Adventures in React 18
Top Content
Featured WorkshopFree
Maurice de Beijer
Maurice de Beijer
With the release of React 18 we finally get the long awaited concurrent rendering. But how is that going to affect your application? What are the benefits of concurrent rendering in React? What do you need to do to switch to concurrent rendering when you upgrade to React 18? And what if you don’t want or can’t use concurrent rendering yet?

There are some behavior changes you need to be aware of! In this workshop we will cover all of those subjects and more.

Join me with your laptop in this interactive workshop. You will see how easy it is to switch to concurrent rendering in your React application. You will learn all about concurrent rendering, SuspenseList, the startTransition API and more.
React Hooks Tips Only the Pros Know
React Summit Remote Edition 2021React Summit Remote Edition 2021
177 min
React Hooks Tips Only the Pros Know
Top Content
Featured Workshop
Maurice de Beijer
Maurice de Beijer
The addition of the hooks API to React was quite a major change. Before hooks most components had to be class based. Now, with hooks, these are often much simpler functional components. Hooks can be really simple to use. Almost deceptively simple. Because there are still plenty of ways you can mess up with hooks. And it often turns out there are many ways where you can improve your components a better understanding of how each React hook can be used.You will learn all about the pros and cons of the various hooks. You will learn when to use useState() versus useReducer(). We will look at using useContext() efficiently. You will see when to use useLayoutEffect() and when useEffect() is better.
React, TypeScript, and TDD
React Advanced 2021React Advanced 2021
174 min
React, TypeScript, and TDD
Top Content
Featured WorkshopFree
Paul Everitt
Paul Everitt
ReactJS is wildly popular and thus wildly supported. TypeScript is increasingly popular, and thus increasingly supported.

The two together? Not as much. Given that they both change quickly, it's hard to find accurate learning materials.

React+TypeScript, with JetBrains IDEs? That three-part combination is the topic of this series. We'll show a little about a lot. Meaning, the key steps to getting productive, in the IDE, for React projects using TypeScript. Along the way we'll show test-driven development and emphasize tips-and-tricks in the IDE.
Web3 Workshop - Building Your First Dapp
React Advanced 2021React Advanced 2021
145 min
Web3 Workshop - Building Your First Dapp
Top Content
Featured WorkshopFree
Nader Dabit
Nader Dabit
In this workshop, you'll learn how to build your first full stack dapp on the Ethereum blockchain, reading and writing data to the network, and connecting a front end application to the contract you've deployed. By the end of the workshop, you'll understand how to set up a full stack development environment, run a local node, and interact with any smart contract using React, HardHat, and Ethers.js.
Master JavaScript Patterns
JSNation 2024JSNation 2024
145 min
Master JavaScript Patterns
Top Content
Featured Workshop
Adrian Hajdin
Adrian Hajdin
During this workshop, participants will review the essential JavaScript patterns that every developer should know. Through hands-on exercises, real-world examples, and interactive discussions, attendees will deepen their understanding of best practices for organizing code, solving common challenges, and designing scalable architectures. By the end of the workshop, participants will gain newfound confidence in their ability to write high-quality JavaScript code that stands the test of time.
Points Covered:
1. Introduction to JavaScript Patterns2. Foundational Patterns3. Object Creation Patterns4. Behavioral Patterns5. Architectural Patterns6. Hands-On Exercises and Case Studies
How It Will Help Developers:
- Gain a deep understanding of JavaScript patterns and their applications in real-world scenarios- Learn best practices for organizing code, solving common challenges, and designing scalable architectures- Enhance problem-solving skills and code readability- Improve collaboration and communication within development teams- Accelerate career growth and opportunities for advancement in the software industry