It feels like a law of nature that features are added to software at a pace much faster than they are removed. It seems like our nice simple software always eventually evolves into a slobbering complex monster, incomprehensible for its users and unmaintainable by its developers. Is this an unavoidable phenomenon? If so, how can we adapt to that, as software creators?
Many battles have been fought over what is the best way to do state management. A gazillion of strategies and libraries are out there. So... it is time to take one step back. What problems does state management solve, and what are the benefits and disadvantages of the many different state management approaches out there?
We'll discuss the lessons we took from migrating a visual third-party website tracker tool using D3.js and ES6 from SVG to Canvas. You'll learn how to tackle some of Canvas challenges, how to get better graph performance and how all of this can be converted to an immersive virtual reality experience using A-Frame!
In this session, we'll talk about Flutter, what it is, why it's so cool, and we'll see a real-life application and illustrate how easy it is to build using Dart and Flutter.
Service Worker API allows us to implement a whole layer of application logic and has lots of nuances in its behaviour, which we'll cover in this session.
Kamil will introduce Nest to you as well as show internals of the framework's key features.
Illya will try to review the results brought by almost a year of research and selection of technologies and architectural solutions, all to make his team's code more reliable, as he sees it:
- bad and "wrong" code should look wrong;
- it should be easier for juniors (and not for them only) to write right code than wrong;
- all that could be automated should be automated but without additional trouble.
The current state of cryptography in Node.js regarding security, interoperability and performance: what has happened, what is about to happen? What are our long-term plans?
We'll analyze in detail all the opportunities of file uploads by clients, even the most critical enterprise cases. In the end of the talk, we'll get a code you can reuse in your project.
The hype has passed, and that means it's time to dive into the microservice architecture. We'll start with a conversation about the basic principles of technology, considering its basic principles in the light of its advantages and disadvantages. We'll talk about how the services architecture should look like, what problems there are and how to solve them.
GraphQL is not a database — it's a new standard for highly comfortable API, which is now taking over from REST API. In this talk we'll discuss GraphQL on back end. You will learn what is necessary to launch GraphQL Server, how to build schemes and do authorization, and dwell on safety and problems that may appear.
How were the type systems of modern languages shaped, what theory lies behind them and where all of this is going? Let's try to discuss this.
Sebastian will give an intro to the endless wonders we can encounter in the hardware world through our browser windows. Aside from learning the basics of USB and serial port communication, we'll paint on USB displays, live tweet to receipt printers, control an Arduino, steal data from Android phones and many more... The only limit is your imagination.
Everyone talks about functional programming these days, but not many people talk about lambda calculus. In this talk, Lucas will show how you can write code using only functions, or, even better, only birds. Lucas promises your mind will be blown or he'll give you your time back.
This is a talk about a lot of new browser APIs and their combinations that allow us not to trust servers, 3rd party, network connection and even browser itself. Because we can and because being paranoid is good.
Bartosz will show you how to utilize machine learning algorithms and real-time stream processing to recognize gestures made by hand movements.
Sergei will guide you through real world examples and identify solutions and best practices for making charts accessible.
Erik's talk will discuss the lessons learned from building and maintaining the most popular form library, and how they were used to create a new form library, optimized for minimal React rerenders, but also powerful enough to be used with other libraries.
This talk will focus on what distributed tracing is, how to roll it out across your infrastructure, and how to use it to gain better insights and fix problems.
You'll see what happens when we mix computational power and the greatest works of art the world has ever seen! And guess what? All that using Node.js. Hold tight, art class is about to start!
The main part of the talk is to show how to import a 3D model to a WebGL scene using Three.js, how A-Frame is leveraging this to enable developers to create a simple 3D VR scenes and where is WebXR in all of this.
Stas will tell about inner workings of webpack using loader for work with SVG sprites as an example.
Asynchrony: hooks (async_hooks), Continuation (or Thread) Local Storage, Tracing, Duration, statistics, analytics and error processing.
This talk covers making a game for developers (not only front-end ones). Why RxJS and Workers are cool, but the most popular game engine isn't? Is it possible to make JS safe and developers happy? How to survive loads of events and criticisms and release your game for the Day of the Programmer?
Victor will show how the "giternet" with Merkle trees and peer2peer replication works (using DAT, IPFS and possibly other technologies as examples) and how to put a simple site (with blackjack and CDN) on it.
This talk's purpose is to show that you can and should develop in 3D. It is aimed at developers who want to start developing 3D applications, but get confused by complexity. You will learn how to make your own 3D engine right now.
We'll discuss the following topics:
- What is Data Science and why we should know about it?
- How Data Science can help us in front-end and what we should do for it?
- Demo of a new data analysis tool and why we created it.
- Case studies, what can be done by now and in the future.
This talk is about pitfalls we fell into while moving our big app to C++ in browser.