Why so Reactive? The story of (React)ive state management

Community has gone crazy over SolidJS and Signals, and for a good reason. It's been awhile since we've seen this kind of alignment within community, where everybody now has a signal primitive. Well, almost everybody :)
React doesn't have signals, and there are no indications that it will have signals any time soon. Since it is not truly Reactive, what can we do to bring fine-grained reactivity to React's ecosystem? How can we build signal-like state management within React web applications and how can we build reactive systems with React?
This is the story of (React)ive state management.

(React)ive Offline-first Web Apps

Crafting bulletproof offline-first web applications is an art form. Sure, you know the basic steps for handling fickle networks, but true resilience demands a maestro's touch – the ability to orchestrate offline actions and weave a seamless user experience. Enter RxJS!
In this session, we'll unveil the secret power of RxJS as it gracefully reacts to offline events, updates the UI, and orchestrates actions with the precision of a symphony conductor. Prepare to be enlightened! 🚀

Detailed description for the committee board:
In this talk, we will explore how to build awesome offline-first web experiences with the help of Service Workers and some common offline recipes like:
1. Cache-First strategy
2. Network-First
3. Stale-While-Revalidate
4. Cache-Only
5. Network-Only

What stands out in this session is that we are going one step further than classic recipes, flavoring these examples with RxJS Reactivity to orchestrate the whole process. In the end, we are going to explore 1 awesome library called RxDB (https://rxdb.info/), which can help us with creating offline-first apps even more easier.

Secret Shortcuts of Loading Web Performance

When optimizing the loading performance of web apps, everything is easy when we Google a little bit and apply standard optimization techniques like minimizing & compressing files, using tree-shaking, inlining critical CSS, using next-gen image formats, applying caching headers, using server-side rendering, etc... But what if, that is not enough and we need to go above & beyond that? That's where we need to take secret shortcuts, so we can boost the loading time of our app to the speed of light 🚀🚀🚀

This talk has the answer to the question of what secret shortcuts are of Loading Web Performance, with a lot of real-life examples in React.

Previous talks:
https://www.devbcn.com/speaker/6450a887-0015-43d3-be49-630a1948e4b8
https://www.developerweek.com/europe/speakers/
https://gdg.community.dev/events/details/google-gdg-torino-presents-devfest-alps-2022/
https://jsconf.jp/2022/talk/secret-shortcuts-of-loading-web-performance/
https://www.youtube.com/watch?v=SOCdb8SufhU
https://reactweek.dev/#speakers
https://www.geekstone.org/sr/po%c4%8detna/doga%c4%91aji/geekstone-meetup-dva-predavanja/

Slides:
https://nikola-mitrovic.slides.com/nmitrovic/loading-performance-ca7b02

Superpowers of browser's Web API

When writing code for the Web, there are a lot of capabilities that are offered out of the box by our browsers. If you ever wrote a File Upload component, used timers and intervals, interacted with the DOM, or stored something in the Local/Session Storage, you had to go to the MDN’s Web API docs, to find some relevant information on how to implement that code.

In this session, we will delve into the exciting world of browser Web APIs that are not so commonly used (although they should be) and explore their incredible capabilities 🚀

All these features offer new opportunities for creating immersive web experiences that can help businesses grow and connect with customers.

So if you are the kind of an engineer who wants to stay ahead of the curve when it comes to web development, learn how Intersection Observer, Background Sync API, Screen Wake Lock API (and many more) can help you create better web applications that will keep users engaged and coming back for more!

Abstract:
In this talk, we're about to reveal some of the browser's built-in functionalities that we often overlook and find out how powerful our browsers actually are.
Some of the APIs that we're looking to explore:

- Intersection Observer
- Network API
- Screen Wake Lock API
- Page Visibility API
- Background Sync API
- Broadcast Channel API
- Web Speech API
- Web Authn APIs

And all with real-world examples written in React 🚀🚀🚀

Previous talks:
https://www.youtube.com/watch?v=wXx82nhb524
https://www.youtube.com/watch?v=iWuqMq0I3AE&t=1s
https://challengeaccepted.dev/
https://www.meetup.com/js-eindhoven/events/291205657

Slides:
https://nikola-mitrovic.slides.com/nmitrovic/superpowers-of-browser-s-web-api-9efb20

Secret shorcuts of JavaScript Performance

In this session, we’ll peak under the hood of the V8 engine, which is the key piece when it comes to parsing & compiling JavaScript, whether in our Chromium-based browsers, or NodeJS and Deno backend runtimes. What is a Just-In-Time compilation, how do V8’s parser Ignition and compiler Turbofan work together, and how understanding concepts like Speculative Optimization, Hidden Classes, and Function Inlining help us write blazing-fast JavaScript code, are only some of the questions we’re going to reveal. And all of that with live coding examples and performance metrics.