Discuss the future of development with tech leaders from across the world.

ReactiveConf

The React Productivity Revolution

Flutter, Google's open-source platform for developing high-performance mobile applications that run on multiple operating systems from the same codebase, sports a modern reactive architecture in addition to an attractive widget library. This talk covers how to adapt state management strategies like Rx and Redux for use with your Flutter application.

Architecting the Reactive Flutter App

Let's Tree-shake it...

Client-server synchronization is the next frontier. Now that DOM/UI rendering is more or less solved on a frontend, and efficient servers are easy to write, we need a good understanding and solid model on how to pass data around in a reliable, efficient and easy-to-use way. What makes it interesting is that there’s no good answer to that question yet, so a lot of discussions, papers and libraries are happening right now. Another thing is that it seems that we’ll need to change the way we think about data, and the change will affect client, server, DB and maybe even our programming languages. 

Client and server need to talk

Almost 3 years ago, the first experiments concerning “CSS in JS” have emerged. In 2017 - at least since styled-components got released - writing styles in JavaScript is not at all experimental anymore. Many developers are still sceptical about it.

This talk summarises both the good and the bad parts as well as the opportunities & future possibilities of CSS in JS. It will help to understand how everyone can benefit from writing styles in JavaScript. It will not give any advice on which implementation to choose.

CSS in JS: The good & the bad parts

In this talk, we’ll cover how we can build an advanced compiler that turns the constraints of templates into a powerful advantage. By modeling web applications as a specialized bytecode that runs on top of an optimized VM, we can produce code that starts fast and stays fast out of the box.

Creative Hacking: Delivering React Native App A/B Testing

Logux is a new project which replaces AJAX by synchronizing Redux actions in real-time between client and server. It is based on the ideas of CRDT and brings plug&play support for live updates and offline editing. Andrey Sitnik, the creator of PostCSS and Autoprefixer, will explain how his team, Evil Martians, uses Logux with Amplifr, its difficulties, and the resulting productivity boost.

Using Logux in Production

At the end of May I've announced together with Lee Byron that GraphQL Subscriptions are now officially part of the GraphQL Spec.
That is a big deal for all real time apps out there!

But when adding real time capabilities into your app there is a lot to consider - both on the client and the server.

In this talk I will explain the concept of GraphQL Subscriptions, why it's such a big deal for real time apps, but mostly talk about how to make it work in your existing app today, no matter how large or old it is...

GraphQL Subscriptions - Scaling real-time in the real world

Jest as a Platform

With the rise of modern JavaScript build toolchains such as Babel, webpack and PostCSS, compilation has become an indispensable step in building JavaScript applications. This compilation step, in addition to providing access to new language features, also provides the opportunity for performance optimizations. Minification is one such example, but there are many more possibilities. This talk will explore some existing ideas in the category of build-time optimizations, introduce related work in the Vue ecosystem, and discuss some ideas for future experimentation.

Compile-time Optimizations in JavaScript Applications

RON: Replicated Object Notation

When we talk about D3 and React, the conversation often becomes: who should have control of the DOM? After all, React is a view layer and its whole purpose is managing updates to the DOM so we don't have to. D3, on the other hand, is a library for building data visualizations with web technologies - and sometimes, it too needs access to the DOM. So when should React have ownership, and when should D3? And stepping back, when should we even use D3 and React together? If all we want is a visualization, D3 is more than enough, so at what point do we need to add React to the mix?

In this talk, I will give guidelines on when React should render to DOM, when D3 should instead, and the pros and cons of each approach. More importantly, I will cover the interactions and applications that will benefit the most from using D3 and React, together.

D3 and React, Together

I've just spent a year migrating an application to React and in this talk I'll share my experiences, good and bad, about how it's gone, both technically and non-technically, and cover all the potential pitfalls of a long running migration project.

The application I look after at work is a large ticketing platform that was written using Angular 1 and has not been maintained. With the new release of Angular 2, we made the decision to migrate off Angular and onto React. In this talk I’ll discuss why we did this (without criticising Angular, it has served us well) and how we’re migrating in small chunks. A big rewrite was off the cards; this application is business critical and as such we can’t afford to not be able to fix existing bugs or quickly add features because we’re rewriting. Instead we’ve split the work down into many small pieces that we can tackle one at a time. I’ll go through some code examples and talk not only about the benefits but the negatives too, because it’s not all been plain sailing. We’ll see how React’s approach and characteristics make it very adaptable and we’ll look at how we updated tests as we went to ensure our migrations maintained feature parity.

If you’ve got an existing application you’d like to migrate this talk should give you plenty of ideas about doing it in a non destructive way without rewriting and building from scratch.

Lessons Learned Migrating Complex Software

ReactXP: How We Rebuilt (Almost) All Skype Clients

Today we have languages like ClojureScript, BuckleScript, and Elm, which treat JavaScript as bytecode; they compile to it, but do not emulate its design. They make it possible to build an entire modern web app without knowing JS.
Picture that same approach applied to HTML and CSS, and you've got elm-style: a library that doesn't have goals like "let's make vertical centering in CSS easier" but rather "let's scratch-build a layout and style system where vertical centering is innately easy. Where accessibility is natural and not an afterthought. Where it's as easy as possible to go from the design in your head to working software, and where you can maintain it once it's in production."

It's now possible to ship an entire responsive, performant, accessible, web app without knowing JavaScript, HTML, or CSS. Come find out how!

CSS as Bytecode

Randomized testing is a concept popularized by the Haskell library QuickCheck which uses function input type annotations to automatically generate many randomized sample inputs for a single test case. Here we talk about a JavaScript port of this idea that instead uses Flow type annotations.

Property-Based Testing for Godly Tests

You may have heard a bit about Reason -- the new initiative out of Facebook to bring JavaScript-flavored OCaml goodness to web developers everywhere -- but what's the big picture?
Reason has a lot of things going for it: fantastic JavaScript interop, a powerful, battle-tested type system with cross-file inference, macros, and plenty of hype. It was started by the folks at Facebook who invented and built React, and already powers a substantial portion of Messenger.com.

We'll go over the basics of Reason, and answer these questions:
- What does it look like to write React UIs with Reason?
- When will Reason be ready for me to use at work?
- What does it look like to incrementally adopt Reason in a JavaScript codebase?
- What tradeoffs has Reason chosen, and how do they compare to other languages?

Reason: JavaScript-flavored OCaml

Some people will tell you that templates are a “less powerful” way to build UIs for the web. But what happens if we view Handlebars templates through the lens of a high-performance functional reactive programming language?

Secrets of the Glimmer VM

As superfluous as something like animation may initially seem, you can tell a lot about framework by the way that it handles the concept of time. Idiosyncrasies and race conditions in rendering reveal themselves, pauses in DOM and virtual DOM diffing can be exposed.

This is one of the ways Vue shows itself to be uniquely capable and elegant as a framework. In her talk Sarah covered the use of the transition component and some of its offerings to create fluid effects in the browser. Then she discussed watchers and transitioning state and finished up by talking about lifecycle methods, asynchronous updates, and pushing our animations to the next level.

Animating Vue

Unique Value Proposition of CSSinJS and the Future

Styling Components for React UI Kits

Relay Modern or Apollo?

Reactive programming is perfect for some use cases in web development. For instance, Angular’s HTTP module transforms HTTP requests to RxJS Observables by default. If you enjoy using Lodash or Underscore, think of RxJS as their async version. What does this mean? What are Observables? How should you chain HTTP requests the RxJS way? This and more will be presented and show cased in on an Angular Application.

Reactive Programming with RxJS

Open Source 2.0

Understanding webpack from inside out

Styling in CSS

Gavin Doughtie AMA

Tiago Forte AMA

David Nolen AMA

Richard Feldman AMA

Jared Forsyth AMA

Igor Minar AMA

Evan You AMA

Navigating the Frontend Landscape Without Encountering JS Fatigue

Coding Dojo

Evolutionary Frontend Architectures with Angular

Mobile-First IoT-Ready Cloud Architecture

15 less known webpack features

Inspiration talks

Through the Sound Barrier

The State of Mobile Development

Lightning Talk - Matthias Rella

Lightning Talk - Albert Nemec

Lightning Talk - Darpan Kakadia

Lightning Talk - Gregory Shehet

Lightning Talk - Honza Brecka

Lightning Talk - John Wargo

Lightning Talk - Kamlesh Chandnani

Lightning Talk - Lenka Vondrackova

Lightning Talk - Pavel Aksonov

Lightning Talk - Richard Feldman

Uri Goldshtein (https://github.com/urigo), introducing the new GraphQL Codegen. you can generate typings, REST endpoints and even full backends!
Check it out here: https://github.com/dotansimha/graphql-code-generator.

ReactiveConf 2017

Oct 25 - Oct 27 | Bratislava, Slovakia