Submitted talks so far:

Kristijan Ristovski: Markdown + React = 💙

[I'm going o talk about] writing a markdown editor which will output customizable React components, and also accept custom syntax for rendering custom React components. The talk is going to explain the following things:

- Writing a markdown editor in React

- How to render the markdown syntax as React components

- How to customize the rendered React components

- How to plug-in custom syntax for rendering custom React components The final result will look like this 👉 👻 spoiler alert 👻

Neonto: React Studio — a GUI tool built specifically for React

Writing React.js is fun… But being able to draw React components, design responsive layouts and create entire app flows visually can be even more fun! (Especially for those non-coder members of your team who think ECMAScript 6 is a skin disease. They should see the light of React too.) In this lightning talk, we’ll give you a world premiere sneak peek at React Studio (www.reactstudio.com), a GUI tool built specifically for React. We’ll explain how React’s functional design makes it a great fit for visual tools. Also we will show how React Studio’s plugin approach makes it a really powerful meta-programming system. Want to switch your app from Redux to Alt.js or vice versa? Just swap the state plugin and export again! That’s just one of the joys of using a visual system for your Reactified visual design.

Maayan Glikser: Introduction to BDSM

Every day we work with multiple teams to build our products, communication and sync are key factors to deliver your product on time without compromising quality. In this talk I will introduce BDSM a new mocking tool that will change the way you coordinate between client and server teams minimizing friction allowing each team to work at its own pace while keeping in sync.

Ján Švantner: Theming of React Native components

Have you started with your RN application and now it is the time to make it beautiful with nice colors? Although you defined your components and you can add colors there, you want different colors in different situations (those inverse headers are so nice 💕)) What if you could simply replace original RN components and styles would be added automatically. react-native-themeable provides themeable replacement (i.e. implements same API) for RN components. Since all your components are made from those, it is pretty straight-forward to add theme styling to them 🎉. They work within contexts so same component can be styled differently based on the situation.

Dmitry Loktev: Use case for react-native-macos

React Native for macOS (a.k.a React Native Desktop) started as an experiment a year ago, just out of curiousity and the active stage of development also took place during the previous Reactive conference right in the hotel room in Bratislava. 5 minutes talk about why you probably haven’t heard about any real desktop application based on RN, and for what kind of applications it might be perfect fit.

Aleksey Kulikov: With good naming convention, CSS works pretty well

Recently CSS has got a lot of negativity. But I would like to defend it and show, that with good naming convention CSS works pretty well. My 3 developers team has just developed React.js application with 6561 lines of CSS (and just 5 !important). During one year of development we had 0 issues with CSS. No refactoring typos, no style leaks, no performance problems, possibly, it is the most stable part of our application.

Tucker Connelly: Write-once, run-anywhere React Native with media queries

If you need to build a cross-platform app, you can dramatically cut your development time by only writing your components once, and letting the libraries figure out the implementation. Necolas laid an awesome foundation for write-once React Native with react-native-web, which lets you run React Native apps in the web, and this is great for mobile web, but what happens when you try to scale up to tablet and desktop resolutions? And how do you do it in an elegant, write-once manner? Once solution I’ve found is adding cross-platform media queries.

Jakub Chodorowicz: Move all your side effect to middleware using redux-saga

Redux saga is side effects middleware which allows us to orchestrate even very complex logical flows — think multiple AJAX request which depending on the responses, writing state to localstorage etc. More over it’s output are descriptions of actions which can be later processed by middleware, which makes it pure and easily testable. This talk would be a short intro to redux-saga, which would hightlight benefits of concentrating all of side effect in one place and making both actions creators and sagas pure and easily testable.

Even Stensberg: Cyclic References in ImmutableJS

Cyclic References with ImmutableJS is making a lot of builds break when going from mutable to immutable data structures. Through this lighting talk we will go through workarounds to deal with cyclic structures in ImmutableJS, some pitsfall you can make along the way and how to approach ciruclar references in your React/Redux applications. The talk will end with some thoughts about how we can make immutable data catch cyclic references, so we can benefit from only having an reference to our structures. If we got time, we will also go through some handy tricks in ImmutableJS that hopefully the audience will benefit a lot from.

Adam Terlson: Reconceptualize your entire app as a function

I will articulate what I have come to find to be a superior approach to building React applications — treating them as functions, not templates. I will introduce how to:

- Separate the application you’re building and the platform its on from the components you write (Hey, that’s this one! Read on!).

- Inject state into your application, and what a “container” aka “connected” aka “smart” component really is.

- Implement more complex features by leveraging Higher Order Components and a compose function — it’s awesome.

- Make your application UI understandable by looking at a single file, not dozens.

- Make your codebase flat without sacrificing grokability.

Marcus Kleppe: The Zen of Coding — How to Reduce Your Average WTFs/minute

In this somewhat unorthodox lightning talk I will share a simple meditation technique that I apply regularly in my daily coding. It helps me to solve problems faster and come up with new solutions while at the same time being calm and less stressed out after work. Also my back pain reduced significantly. And as a result your WTFs/minute will dramatically decrease as well.

Doug Wade: Lessons we’ve learned running React Server in production

React is an amazing library for client-side user interface, and it has the added benefit of being able to be rendered on the server, which is crucial for SEO, SEM, and user experience. However, server-side rendering in practice is significantly more complicated than just calling ReactDOMServer.renderToString and piping out the result, especially if you want to make sure your site loads quickly in a mobile-first world. React Server smoothes out the common problems you run into with React server-side rendering, encodes performance best practices into the framework, and makes it easy to build high performance websites by default. I’ll discuss some of the design decisions we made during development, show our performance improvements, talk about lessons we’ve learned running React Server in production for a year and a half, and give some hints about the future of React Server, including adding streaming to React core.

Nicolas Cuillery: Recent updates in Jest

Jest is the test runner -and I quote its contributing guide- “used to ship code to everybody on facebook.com”. It’s the React and React Native test runner and it’s used as a day-to-day tool by the team engineers. Either you’ve never heard about it or you’ve given a try to it some months ago, you may be wondering how Jest could assume such a responsibility ? Well, it’s true that Jest hasn’t followed the same adoption curve as other parts of React ecosystem. It wasn’t well maintained, the configuration and setup process wasn’t great and it was slower than expected. But unlike React, Jest had been open-sourced very early and today most of these points should be considered as youth problems since it is well supported by Facebook and the community.

Johannes Stein: React (Native) and the cross platform pipe dream

Have one codebase, target all the platforms. While we are on the topic on re-using the same codebase, maybe we could even switch out the renderer with what is the fatest for the situation. Use DOM, Canvas or OpenGL whenever needed. This lighting talk will give impulses on how to approach this mantra and what advantages and disadvantages we might run into in the process.

Jonas Coch: An API search engine in Elm for Elm

Elm is a statically typed functional language that compiles to JavaScript. It’s well-known for its developer experience: the compiler provides nice error messages, the package system enforces semantic versioning for all published packages and makes sure every exposed value or type has some documentation and type annotations. Elm-search builds on these nice properties and provides a search engine for all exposed values in the latest versions of all published packages. One can either search by name or by approximate type annotation. It’s like a basic Hoogle for Elm. In this talk I’ll show how the indexing and searching works, how Elm made it nice to develop and how the search can assist developers in their work.

Andy Stannard: Ups, downs, and highlights of using React at a Startup Weekend event

With all the plugins, boilerplate projects, SAAS and PAAS offerings plus great community support, what can be created in a weekend? I will take you through the ups downs and highlights of using react at a Startup Weekend event, showing what can be achieved and how. This will be a story of a wild weekend full of tips, framework and plugin summaries plus pictures from the weekend as the startup team attempt to validate an idea. The talk will be a great insight into how react can help you rapidly prototype a business idea, with what went well and what went badly.

Evgeniy Sokovikov: The most pragmatic way to write a mobile app

I want to talk about different approaches in writing mobile apps. I will tell you when it is a good idea to pretend that your responsive website is an app. Also about evolution of this idea from basecamp and DHH — turbolinks. I will tell you about my lovely ReactNative and the problems it has. When you can’t avoid writing apps in native sdk and what difficulties you may face going this way. Last year I used to write apps in objective-c. My open source works mostly around react native but my heart is with Ruby on Rails.

Juan Soto: Intro to AVA

AVA is a JavaScript test runner that runs your tests concurrently and your files in parallel, giving you maximum speed (especially when dealing with IO!). Other features include built-in Babel (including async/await functions), test macros, watcher, TAP output, great assertion messages through power-assert. By the time of Reactive Conf we’ll have even more great features. My lightning talk would be an introduction to AVA and how it can benefit your React and Node testing with its speed, developer experience, and isolated processes. There’ll be a lot of code and theory to explain why and how concurrency helps and how atomic tests make your life easier. It’s a great project!

Nik Graf: Rich text editing with DraftJS Plugins

Earlier this year Facebook open sourced its React based rich text editing framework Draft.js. At Facebook it powers status updates, comments & notes. Others used it to build editors matching Medium’s experience. Together with a whole team of open source contributors I built a plugin architecture on top of Draft.js. In this talk I walk you through the existing plugins and show how you can build your own feature-rich text editor for the web with only a handful lines of code.

Jean Carlo Emer: Thinking metrics on React applications

In regular websites, it is common to sent multiple events to track users clicks. Single Page Applications change the way you look at metrics. This talk is about a simple framework we created at Globo.com to manage a metrics layer for http://globoplay.globo.com. The talk will cover how to track user flow using Google Analytics and other services. The challenges we solve were tying metrics and components, keeping information across pages and having global data. Also some React, React Router and React Side Effects concepts like context, higher order components, history state will be covered.

Rolf Erik Lekang: Enforcing codestyle changes over time

We learn and evolve as projects goes on, so does our codestyle and what we view as best practices. It is fairly common to use linters to enforce a certain code style within a project. The problem arises when we want to add a new rule, but the codebase already breaks this in thousands places from before. How do you tackle that? Especially when there is that deadline coming up. This talk would be about the how this problem was approached by using information from git to filter the lint errors with a tool we created, lint-filter. I will touch on why we created lint-filter, our experiences and what I would consider before using this in a project.

Ondřej Bartas: React is the new Lego — how we deal with a lot of components

At Blueberry, we’ve been frustrated with maintaining and getting oriented in our React components and their props. That’s why we made a tool for automatically generating a component library from a project’s components. We named it BlueKit and released it as open-source. Developers, designers, and other project members can use the generated library to browse through components in a project, tweak their props, and see a live preview of these changes. I’ll talk about the problems that inspired us to make BlueKit and how it can help React devs with their projects.

Thomas Parslow: Type checking JavaScript with Flow

JavaScript is a dynamic language, and there’s nothing wrong with that. It allows quick iteration and lowers barriers. However, sometimes some compile-time type checking is just what you need to keep your code in line and give yourself the confidence to build bigger and faster. Flow gives the best of both worlds. You can have normal JavaScript but you can also add types where they’re helpful, and it adds zero cost at runtime. In this talk I’ll show Flow as it applies to a Redux & React codebase.

Patrick Stapfer: A Life on a Commandline

As a JavaScript developer, could you imagine using something else than Atom, Sublime or other IDE-like text-editors? In their daily work, people wrangle a lot with different applications, editors, windows, browsers and loose a lot of time because tools getting in their way. A lot of people are using the terminal already. So why not just leverage it to its full extent? In this lightning talk, I will present how I will do regular JS / React programming just in one terminal window.

Gregory Shehet: Road from UndefinedLand

I work at Grammarly. We like React and happily use it in our applications. However, sometimes something goes wrong and bugs creep into the code. Here comes testing. It helps make us confident about the quality of our code. My lightning talk will be about unit testing of the React applications using Enzyme. I will talk about convenient ways of doing it with the help of Tape-Enzyme library. Tape is a great test runner. We extended it to simplify testing of React components. I’ll tell you about the problems that led us to make Tape-Enzyme library and the benefits of using unit tests.

Javi Velasco: Styling in React