JavaScript
& React Conf

Our data models can be crazy. Sometimes you take a quick look and you already see that if-else to handle it properly. But if you use TypeScript you can handle most of it on the compilation level. I will show you how I’m dealing with strange types cases and how to avoid type-mess in your app.

What’s the magic behind React rendering process. Deep dive into how does React render components - JSX, props and render mechanism. When components are re-rendered and how to avoid unnecessary re-renders - possibilities in latest React.

“Micro Frontends” is the new buzzword in the Frontend world, but too many times people use it in the wrong context or with different things in mind.
Micro Frontends can refer to different kinds of solutions that solve different types of problems - starting from using different UI frameworks on the same app or letting different teams work on separate parts of the code independently.
In this session, we’ll go over the different problems we have when building a big app and how different micro-frontends solutions can help with this.

Do you like writing new code more than doing refactoring? What if I told you it’s possible to write code that refactors your other code?
This talk will get you started on using the benefits of Abstract Syntax Trees in your codebase.

“Storythinking” is not another piece of marketing jargon - it is a philosophical approach to a human problem: the production and consumption of information. Stemming from years of data visualization experience in fields such as academics, sports analytics, and the culinary arts, Monica will take us through the profound importance of appropriate design and development of data visualizations. B2B marketer turned programmer, Monica will shed light on what makes a story built from data compelling, how to approach such stories with a critical eye, and share some real-life examples of how the same data can lead to entirely different interpretations.

When it comes to writing code, there’s nothing we take more serious than authentication and security. Modern single page applications bring along new challenges. By using solutions like the OpenID Connect protocol and JSON Web Tokens we can improve the user experience when authenticating with your apps, providing a seamless authentication process.

In this talk I will try to explain in depth, the way JSON Web Tokens work and can be used to secure your single page apps. I will explain the difference between using opaque tokens and JWTs. The talks will also give an overview of a modern authentication flow and a step by step breakdown of how it works exactly. No specific previous knowledge is required, but it helps the audience has some experience with authenticating users.

“WebAssembly is a new virtual machine embedded in the browser. It doesn’t transpile to JavaScript like its forerunners; it produces a new binary format, like the old assembler, executed in a dedicated VM into your browser. Genius, it exposes a bridge between JS APIs and WebAssembly executables. Last browsers engines developments allow very fast exchanges between JS and WASM code.

So, let’s start with a projet that need a huge computing time. We will develop the core code in Rust, compile it to WASM using LLVM, and we will display the results in a front view powered via JavaScript. No need to know how does it work, we will see it together.

This talk takes place in a new series named #StartFromNowhere: let’s start from front-end developers skills, and deep dive into a new technology. In 45’, let’s learn the basics.”

In daily basis where billions of billion devices are connected to the internet, browsers can actually take control Things like lightbulbs, robots, printers, NFC tags, toys, drones, and many more Things via web standard APIs such as WebBluetooth, WebUSB, WebNFC, Shape Detection API and etc. How about connecting to IoT gateway which supports Wifi via BLE ?!

On the other hand, Progressive web apps open a new era to build web apps that work offline and resemble native apps. PWAs are installable too, therefore, your solution to controlling Things in the real world can be written once for web and reuse everywhere.

In this session, I am going through some of the web capabilities to connect devices into a progressive web app and demonstrate how the web, eventually, could go beyond the browsers.

Developers are people too, and should be your primary concern when designing an interface for them to configure your tools and libraries. In other words, there are better options than JSON available, but they each come with associated costs and limitations. How well do JSON5, YAML and TOML play with each other, and what else is out there? How do the tools associated with these languages compare, and when is writing your own the right choice? And do you even really need config files?

Did you ever have a situation that you had to rewrite your tests after a refactoring? Or did you struggle to even write a test, as it was getting really complicated? Don’t worry - you are not the only one and it’s the best indicator of ultimate evil - testing implementation details. There are many ways testing React components can go very wrong. On the other hand, with all the tools we have available, and the nature of React itself, it’s not that hard to write great tests for our applications.

In this presentation I want to show how to avoid many different problems by testing your components on correct level and with proper scope when it comes to details exposed in tests. And why “unit” in testing doesn’t have to mean the smallest piece of code possible.

I will show few techniques and tools to make writing tests pure pleasure. On top of this - using TDD in the process. I will also show how to write better Enzyme tests with enzyme-custom-wrappers, that I created.

“map() and filter() don’t excite you anymore? debounce(), switchMap() & scan() are your bread and butter? Feeling throttle()-d?
Let’s go beyond what we’re given by RxJS operators library and build some…
…custom operators!

Operators are one of the most powerful tools in RxJS. With almost 100 built-in operators we will almost always be covered.
But there are moments when we would like to create our own operator. Either to make some operations more expressive or extract a reusable group of operators. Or maybe, if we really need it, we would like to implement our own custom operator from scratch.
With pipeable operators introduced in version 5.5 of RxJS it’s much easier to do that. In this talk I’ll show you how to implement your own custom operators.”