Chain React is the U.S. React Native conference where hundreds gather to hear speakers from all over the world share knowledge on writing React Native apps on iOS/Android/Windows and other platforms.

Chain React was started in 2017 by the team at Infinite Red, who wanted nothing more than to learn from other React Native enthusiasts, eat great food, and nerd out about redux vs mob-x. In 2018, the conference grew to 500 attendees, with even more vendors, speakers, and events! 

A Conference For React Developers. A two day, one-track React Native conference hosted in Portland, Oregon.

Join us at the beautiful Armory in downtown Portland this summer! Chain React: The React Native Conference will consist of multiple talks on React Native given by mobile software engineers at Facebook, AirBnB, and others, on a variety of topics from beginner to expert level. We’re expecting a few hundred attendees and are working hard to put on a great conference. 

Chain React

The Dark Art of Bundlers

This talk is a technical deep-dive of how we use react-native as a means to deliver Checkout experience in our open sourced Paypal SDK. It will also layout how react-native has given us the power to steer without merchants having to reintegrate and republish with every incremental SDK release.

- Why ?

‘Pay with Paypal’ is an option many of us use while shopping online . While Paypal has a solid web experience, we are still experimenting a good solve for the mobile ecosystem. Since we aim for stellar experiences we will need to iterate and learn quickly by A/B testing. But at the same time we need to be mindful of not having to force our merchants to continuously upgrade Paypal SDKs and publish updates on the app store. After some research/ investigation into options, we decided to build our SDK using 
react-native.

- How ?

The SDK will be a native shell which will place a react-native root view into the Merchants View Controller that is initializing the Paypal SDK. This root view acts as a seed to initialize Paypal experiences. Whenever the react root view is initialized, we will pull down a checkout react-native bundle from the cloud which will host the payment experience within. 

When the SDK detects that a Paypal payment is initiated, the react-native layer is informed and it hosts the appropriate experience to complete the Payment (either opens a SFVC with the right mobile optimized web experience or natively put up a Paypal Pay sheet modal). 

Once the Payment is complete we close out the react-native hosted experience and the native shell places the merchant app in the right state, post payment. By this, we could sandbox and control the Paypal payment experience we host within the react-native layer, without interfering with the merchant app’s workflow. And the Paypal SDK integration will be a one-time easy process for the merchants !

PayPal Checkout with React Native

Discover how to leverage the new JavaScript language features and apply them to our React Native project.

JavaScript is evolving quickly. The ES6 specification was released back in 2015 and has been implemented by modern browsers. New versions of ECMAScript will now be released on a yearly basis. We can leverage ES6 and functionality slated for future versions right now to write even clearer and more concise React code.

Experience with React will help you get the most out of this session, but you don’t have to have a JavaScript black belt to leave feeling confident in using ES.next with React. Learn how to write cleaner code using the new spread operator, classes, modules, destructuring, and other tasty syntactic sugar features being introduced into ECMAScript. Oh, and don’t worry if you don’t understand all of those terms — you soon will after this session!

The goal of this talk is to walk React / React Native developers who aren’t familiar with new ECMAScript through some of its cool new features (including proposed new ones). But it’s more than just learning ES6+. It’s about how we can apply it (as well as future versions of ECMAScript) with React to write clearer and more succinct code. 

We’ll start off with React’s previous official tutorial that is 100% ES5 and slowly transform it using various ES6 and proposed future ECMAScript features that are transpiled via Babel. I developed a Github repo that is a step-by-step example of how to leverage ES6+/ES2015+ in React by rewriting (an adapted version of) the official React tutorial.

ECMAScript 2015 is JavaScript. React added support for native ES6 classes over a year ago (with v0.13), but there is still lots of developers still writing in ES5. Many coding examples and StackOverflow answers are given in ES6 so it’s important for us in the React community to level up.

React Native + ES.Next

Working consistently across multiple platforms with different file types in React Native can be challenging. In this talk, I will discuss and implement working with and opening a multitude of different file types consistently on both iOS and Android.

JavaScript Futurism

In this talk, we’ll dive into the mobile payments landscape and explore the various ways that we can accept payments in our React Native applications.  We’ll then focus in on mobile wallets and see how we can leverage them to eliminate the payment form and reduce friction in our checkouts.  Finally, we’ll learn how we can do all this while sharing our payment code across platforms.

Mobile Payments with React Native

This talk digs into building rich touch interactions with React Native. There’s a deeper level than Touchable* components and PanResponders. Kyle and Thomas will uncover it, and show off its full potential!

Touchable* components and PanResponder add the magic of touch to your React Native app. They are great for building basic interactions, but to build more complex ones, we need a deeper understanding of how gestures work in React Native.

This talk peels back the layers of React Native’s gesture system, from higher level abstractions like Touchable*, to PanResponder, and finally to the thing powering it all: the Responder system. We’ll go through some of the more simple gestures, then showcase the full potential with custom ones, including bubbling and capture from multiple components. And with our demo app, the audience will be able to interact along with us. 

When attendees leave our session, they’ll feel empowered, not intimidated, by the many configuration options in (Pan)Responder. Equipped with a deeper understanding of gestures in React Native, they’ll be able to build immersive, rich touch interactions for their apps.

Gestures Here. Gestures There. Gestures Everywhere!

In this talk we’ll share Gudog’s experience on rewriting our large Ionic / Cordova hybrid mobile app with React Native (using Ignite, redux, redux-saga & normalizr).

Gudog is a p2p marketplace that connect dog owners and dog sitters in Europe. Our product is nearly as complex as other p2p marketplaces such as Airbnb in terms of features and numbers of screens.

Our first mobile app was built in 2015 with Ionic (Angular.js based framework for building hybrid Cordova / Phonegap apps). This year we decided to rewrite it from scratch using React Native. We’ll share the reasons why we made some decisions regarding our new app and how we have layout our new architecture.

As newcomers to RN as we were, one of the problems we face was the lack of RN / Redux examples for complex apps, i.e. more than 5 or 10 screens. We hope that by sharing our experience we can help others overcome this.

Rewriting a Large Hybrid App with React Native

In this talk I will explore how using React Native with Robotics makes prototyping a breeze and enables mobile control of almost anything.

Why we Need an App Browser

Crossing the bridge between native and JavaScript code can seem daunting, but it doesn’t have to be! This talk will simplify the process of bridging native modules & components by breaking down common patterns found in bridging implementations for iOS & Android.

Whether you’re integrating a brownfield native application, an existing native component, or a third-party SDK into your React Native project, you will eventually have to cross the bridge between native code and JavaScript. This process can definitely be intimidating, especially if you’re coming from a JavaScript background. 

In my talk, I will demystify the bridging process by exposing common patterns and best practices for bridging native components and modules. To simplify bridging concepts, I will show you how to use react-native-create-bridge, a CLI that auto-generates native module & component templates in Obj-C, Swift, and Java. You’ll also learn how to communicate between native modules and JS code by properly utilizing eventDispatcher (iOS) and DeviceEventEmitter (Android). 

By the end of this talk, you’ll leave feeling confident enough in the fundamental concepts of bridging to build a native component or module and use it in your React Native app.

Breaking Down Bridging in React Native

The Evolution of API Design

React Native brought the web’s enviable development patterns to mobile, without needing to sacrifice native UI. Code Push for React Native brings web like release agility to mobile apps by enabling developers to update apps instantly. 

This talk will cover the next iteration of Code Push and how it fits into a complete suite of DevOps services built for called Mobile Center, built for React Native. We will look at the end to end workflow - from a single commit on github triggering continuous builds and tests, to the final, signed app distributed to testers, clients or end users. 

From monitoring services like JavaScript enabled crashes to understanding user behavior with analytics, we will look at ways to get better mobile apps to your users. We will look at the internals of Mobile Center to use with your existing toolchain, other services that are planned as a part of the suite, and integration with popular community tools and services.

React Native: Zero to DevOps

React provides an abstraction between the description of a UI and the details of how it's rendered on a given platform. The problem is that `div` and `span` are a hidden dependency on `react-dom`, and similarly, React Native's `View` is an explicit dependency on Native, making both not quite as "cross-platform" as we want them to be. Learn how we as a community can get around these issues, and what we can unlock by doing so.

React as a Platform

This talk will explore a Serverless Architecture and how it can can aid any React Native developer in building scalable backends for their applications. Our provider of choice will be Amazon’s AWS ecosystem and AWS Lambda, DynamoDB, Cognito and API Gateway will be among the resources covered.

This talk will explore using the Amazon AWS ecosystem of technologies from React Native Apps. We’ll explore the characteristics of a Serverless Architecture and how it can can aid any React Native developer in building scalable backends for their applications.

Our focus will shift to building a Lambda to provide the responses to data needed from an example React Native application. The orchestration of this will be done via the Serverless Framework written to ease the burdens of managing the lifecycle of a serverless architecture.

The example we will talk through will focus on delivering a AWS Lambda, but we will discuss how using a framework such as this for abstraction and orchestration can allow for deploying Alexa Skills, mobile and IoT services serverless architectures.

Finally we’ll have a look at interacting with AWS Lambda, DynamoDB, S3 and SNS using Amazon’s AWS SDK for React Native (currently in Developer Preview) https://github.com/awslabs/aws-sdk-react-native

Attendees will walk away from the talk with knowledge of how a React Native application can interact with a few basic services written and deployed on AWS Lambda via the Serverless Framework. The data for the services will be retrieving from DynamoDB tables which will be also be orchestrated via the framework. 

We will also talk briefly about authentication in React Native with AWS Cognito and how it can be setup as an auth solution for storing and accessing user data in Cognito attributes as well as data stored in DynamoDB and S3.

Building Serverless Backends with AWS Lambda for React Native Apps

React Native is great for writing cross platform apps. Certain use-cases, however, still require native code. Together we will look at how to evaluate when native code is the better choice. I’ll cover strategies for dealing with performance issues and how to handle background tasks like geolocation.

The promise of writing an app in Javascript for iOS and having it “just work” out of the box on Android is a tempting one. That along with hot reloading and the ability to push over the air updates to published apps make React Native a tempting proposition, especially for web developers who are unfamiliar with native development and want to leverage their knowledge of React. However certain use-cases still require native code. 

Together we will take a look at some of these exceptions and how to evaluate when native code is the better choice out of necessity or performance concerns.

This talk will be from the perspective of an experienced iOS developer who has been working with React Native and has shipped several cross platform apps with native components.

Things I will talk about:
- Overview of how React Native works
- Overview of iOS/Android application states and how that effects your apps design
- App use-cases that require native code
- Example app with native code that uses geolocation in the background (code available on github)
- How to use native tools to profile your app (with example app, available on github)
- Strategies for dealing with performance issues
- Cooking demo where I port a Javascript component to Native and show differences in performance (code available on github)

When to go Native Over Javascript

As React Native developers we take so much pride in how fast it takes us to build something functional on mobile. However, the development speed is only half of the story. 

In this talk Alex, a former React Native team member, will share his insight about building amazing user experiences, and how attention to little design details can fundamentally change the quality of your app.

Building stellar user experiences with React Native

We’ll walk through everything involved in taking an app from initial concept all the way to submitting an iOS and Android app to the App Stores.

There is a lot to consider when developing a new React Native application, and even more to think about in order to ship it. 

This talk will focus on distilling all of those requirements into actionable, easy to follow steps that you can use to deliver your next app. We’ll do this by examining an app crafted specifically for this talk, which you can use throughout the conference!

From Idea to App Store: A Guide to Shipping React Native Apps

An analysis of the roughest areas of developing apps with React Native from my point of view. I deal with developers building greenfield apps every day. I see everything from total beginners working on a side project to agencies, large companies, and startups building apps for their clients and their own businesses. React Native has come so far, but we have much more work to do. As a community we really need to step up our game if we want our bet in React Native to pay off in the long-run.

React Native Sandpaper

React Native on the Apple TV Platform

Gant Laborde hosts a panelist discussion about React Native and other tech at Chain React 2017, organized by Infinite Red. 

Panelists include:

Jennifer Van - Capital One 
Sanket Sahu - Native Base 
Mateo Barraza
Matt Hargett
Dave Nugent - Qlik Playground 
Jani Eväkallio - Formidable Labs

React Native Panel With Various Speakers

Realtime Event Processing, Streaming and Subscription for React Native Using Cloud Services

2017

What do you do when the conference you want doesn’t exist? Create it, of course! 

The Chain React Conference was started in 2017 by the team at Infinite Red, who wanted nothing more than to learn from other React Native enthusiasts, eat great food, and nerd out about redux vs mob-x.

As frequent conference attendees ourselves, we knew that the details matter. We flew Derek, our team foodie, to Portland to taste-test caterers and food options; AJ, our resident coffee fanatic, arranged top-quality caffeination. We booked amazing speakers in the industry and chose cool venues to host everyone.

The result: the first Chain React Conference was a smashing success.

One of the things I love about React is how easy it is to encapsulate UI code into a component. I love this because it makes reuse of those components easy. But is it simple? 

I've made my fair share of components that had to accept a bunch of props to handle a growing list of different use cases resulting in a complex render function full of conditional statements and a confusing API for people using this "reusable" component. 

Eventually it becomes too much and I had to make a new version of the same component to handle slightly different use cases. Lots of code/bug duplication there because my reusable component wasn't reusable enough. It wasn't simple enough.

There are patterns that have emerged in React that allow you to promote code reuse without sacrificing the simplicity or flexibility of the component. In this talk we’ll cover some of these patterns that will make your React components more useful.

Simply React

Fragmented ecosystems, a lack of tooling, and secrecy concerns have encouraged us to make a sharp divide between open and closed source projects, but React Native projects can chart a third path. I’d like to talk about how moving more of your development into the public eye can enable new workflows and benefit both your project and the community.

All Together Now

If you've spent any time with React Native, you've probably tried debugging your apps with Chrome. It's handy, it's familiar, it kinda works, but maybe you've thought "this could be better." And you're right: it can be. 

In this talk, you'll meet Reactotron, a free, open-source development tool for your React and React Native projects. You'll see how just a few lines of code will give you access to a world of useful information about what's going in your app. Get better stack traces on errors, peer into the gory details of your network requests, pry open your async storage, subscribe to Redux store changes, debug your sagas, and the list goes on. 

By the end, you'll be ready to start working with Reactotron in your own projects, and wonder how you ever worked without it.

Debugging and Beyond with Reactotron

Working on multiple enterprise projects that use the same components can get a little overwhelming. I will talk through how to create an effective work flow by showing examples of what worked and did not work for our team, from design QA to constant props. As well as how we tackled component documentation that stays up to date with API changes. Lastly we will explore new ideas that we will want to explore like working with AirBnb's react-sketchapp.

From Sketch to Code: Designing a Component Kit

A year in, developing and using Detox in production taught us a lot. From designing its API to consuming it, testing real user scenarios to advanced mocking, we learned what makes sense when E2E testing an app and what doesn’t.

In this talk, we’ll discuss how Detox works and what makes it deterministic, cover some advanced use cases and methodologies, go over new features and tease the ones that are upcoming.

Detox: A year in. Building it, Testing with it

React Native is magical and it’s catching fire. What’s exactly is it? How does it work for iOS AND Android? Not only can you make universal components and save hundreds of lines of code, it allows developers to reuse code across the web AND mobile all with a smooth UI.

Learning React Native as a Junior Engineer

Machine Learning can sound like it is just for big machines with lots of GPUs. But you can execute ML models on your phone! From React Native! And it's not that hard!

We'll skip the neural network charts and focus directly on technologies that can run on your phone today to do cool things like:

1. Classify an image based on what you are looking at - and apply that information through a render prop updated in real time!
2. Use a prop to apply a feedforward "generator" to make instant art from an image or viewfinder preview - fast!

The talk will cover CoreML and Tensorflow Lite, which allow ML models to run locally on iOS and Android as well as some other angles on deep learning technologies that approach the problem a different way.

At the end of this presentation, the audience will have some practical ideas of what they can do with ML, and knowledge of tools that make it easier to integrate artificial intelligence into their react-native projects.

Machine Learning and React Native

In this talk, I will present how to create your custom boilerplate to use with Ignite, looking at most of the options we can add (or make optional), to build an awesome boilerplate.

Customize Your Boilerplate to Speed Up Development with Ignite

The legal cannabis industry is very new and constantly evolving. New local regulations are frequently introduced and app store policies are unclear. Over the past two years, we at Eaze have leveraged React Native for rapid development and iteration of our mobile presence. Our fleet-management app used by our delivery drivers as well as our consumer app have taken many forms and seen several complete re-architectures. 

This talk covers the evolution of our mobile applications, the advantages and shortcomings of using React Native in a grey market industry, and the solid technical solutions that we have implemented over the long term.

React Native at Eaze: Marijuana Delivered

TypeScript has totally changed the way I treat software development and I want to encourage others to give some kind of typed JavaScript a try. While my talk will largely focus on TypeScript (since it is the flavor I am most familiar with), I want to focus largely on the general benefits of type systems and the dev tools that are being built around them.

How TypeScript Ruined My Life (In a Good Way)

With the release of ARKit and ARCore by Apple and Google we see various Augmented reality apps created for iOS and Android. Have you ever wondered how you can create such apps in React Native? In this talk we will see how it can be done fairly easily.

Building AR Apps with React Native

React Native is a platform that bridges the gap between web programming practices and native mobile technology. How does accessibility fit in when it doesn't quite belong in either camp? 

I'll cover some how-tos of React Native accessibility, provide some insight into testing, and how to convince leadership that the time spent is worth it. This talk is sure to leave you with actionable ways to Be a React Native A11y.

Be a React Native A11y

For teams that deliver code for the web, android, and iOS, we want to avoid writing all of our logic three times, in three different languages, across three different platforms. 

We will share how our team was successful in developing features of our platform that realized 70% business logic code re-use between web and mobile and even more re-use between Android and iOS. 

We will discuss the motivations for when it is right to code-share, how to organize your React code and build configurations to accomplish code sharing, and how we approach integrating React components into native Android and iOS app.

Organizing Code for Cross-Platform Web and Mobile Development

There will always be a new JavaScript framework to learn. Technology will continue to evolve and change, and developers will continue to rewrite applications. Wouldn't it be amazing if we could just copy paste 90% of our code from framework to framework? 

Well, you can. Reactive programming enables just this AND the ability to future proof your code. 

Not only can reactive programming help with your solutions to JavaScript fatigue, but the concepts and technology remain consistent from framework to framework.

Learn how to create a more composable application architecture and an arsenal of lego bricks with RxJS, a push based primitive and domain specific language that sits on top of JavaScript.

With its more declarative syntax and intrinsic portability, learn how to use RxJS in Angular, React, and Vue and what the future holds for for reactive primitives in TC39 and WHATWG.

How Reactive Programming Makes Developer Lives Easier

React Native has been around for almost 5 years and has helped many developers build amazing Mobile Applications. 

In this talk, we will look at the current state of React Native with a whirlwind tool of its internals. We will also look at the upcoming changes in the architecture and how it plays well with React Fiber.

The State of React Native

GraphQL State Management for React Native

Hot reloading--the ability to push over the air updates to published apps and the promise of having your app “just work” out of the box on Android as well as iOS--make React Native a tempting proposition for frontend developers. But what do you do when you have to integrate React Native into a large existing native code base?

This talk is from the perspective of an experienced native iOS developer who has worked with React Native to ship several cross-platform Greenfield and brownfield apps.

Things I will talk about:

- Overview of the challenges involved in integrating React Native into an existing app.
- A real life case study integrating React Native into a native app with millions of users.
- Strategies for passing data and events in a brownfield app.
- Working with build systems like CocoaPods
- How to do CodePush in a brownfield app
- How to handle navigation in a brownfield app
- Best practices for working with Native engineers
- Example brownfield application

Strategies For Using React Native In A Brownfield App

Writing 3D applications for the browser is possible since some years due to the WebGL API. But since Virtual Reality and Augmented Reality are getting more popular, web developers and designers now have a serious reason to get to know the 3D web, its APIs and design patterns.

In this talk you will learn how to create 3D applications in the browser, using ReactJS in combination with popular VR libraries, like A-Frame and ReactVR. You will also see what is necessary to create a Virtual Reality app that runs on common VR devices, and how to create Augmented Reality applications for Android and iOS phones.

Since 3D user interfaces and interactions in the browser are relatively new for designers and users, there are no established UX design patterns yet, but you will get to know best-practices and see some tips for improving the usability of your 3d application.

The talk ends with my advice on how to create responsible applications, that won’t harm your users – neither physically nor psychologically.

WebXR: A New Dimension For The Web

Panel

ReasonML and You - A Fireside Chat with Mike Grabowski

Vector graphics is in fact the best way to provide great visualization and interaction combined. It exist on all platforms in some way or form, so it's just natural to use it in React Native. 

In this talk, I'll show you how I integrated the use of SVG with the opinionated component and state system of React, but in the same time keeping things highly performant when interacting with the UI thread - a topic a lot of developers are struggling with.

Using SVG in React Native

React Native has helped teams ship some wonderful apps -- but also many really, really terrible ones. We know it can be done, but what makes the successful ones tick? As React Native scales the hype curve towards a mainstream plateau, we need to have a talk about its strengths and weaknesses, and our responsibility as developers to make our products, and React Native as a technology, successful. 

This talk bridges engineering and art, spans topics from psychology to economics, and whatever you think it's going to be like, it probably isn't.

Good Enough Still Isn't Good Enough

2018

What do you do when the conference you want doesn’t exist? Create it, of course! 

The Chain React Conference was started in 2017 by the team at Infinite Red, who wanted nothing more than to learn from other React Native enthusiasts, eat great food, and nerd out about Redux vs MobX. In 2018, we upped our game, adding more vendors, two workshops, and even more great speakers.

As frequent conference attendees ourselves, we know that details matter. From caffineation to caterers, from icebreakers to mixers to after parties, we put a lot of care into designing the conference to be fun and to maximize learning and networking opportunities.

Note: there's a problem with the audio until 2:13 into the video, after which it is fixed. We apologize for the inconvenience!

Facebook drops a huge announcement at Chain React 2019! Marc Horowitz from Facebook gave us a look at Hermes Engine, a small and lightweight JavaScript engine optimized for running React Native on Android.

Hermes Engine Announcement

The problem: You're starting a conference. You announce the conference, start planning the venue, getting sponsors, & fielding talks. Things start getting serious, & before you know it you're overloaded with obligations. Oh, & you forgot: You also need a conference app!

You don't just want any conference app; you want it to be fun, engaging, & a valuable addition to the attendees. How can you do this in the least amount of time?

The solution: In this talk, I'll show how you can rapidly prototype, build, & deploy your app using GraphQL, React Native, & AWS AppSync so you can spend your time worrying about more important things in life. In addition to what you'd expect from a conference app, we'll be adding live chat so attendees discuss talks & speakers can field questions & interact with them in real-time.

Slides/Repo - https://github.com/dabit3/conference-app-in-a-box
https://github.com/dabit3/chainreact-admins

Hooking Up a Conference in Real-time with GraphQL

While React Native leverages the platforms native API and user interface elements to build mobile applications, transfer of control between the various layers could sometimes come at the cost of performance. 

In this talk, we will look at the various tips and tricks for taking full advantage of React Native and using the performance attributes of the new architecture. 

We will start by adding instrumentation to a sample application across the Javascript, Java/ObjC and C++ layers. Next, we will look at how this information can be used to improve at specific places in the render process. Finally, we will look at rounding up our performance practices by adding this to our CI system to ensure that the apps we build with React Native stay smooth and blazing fast.

Performance in React Native

Jetpack Compose is a new declarative UI framework that is being developed in the open for Android. It has a very similar programming model to React, and this talk will dive deep into the internals of both to explain the similarities and differences in the architectures of both, and how React Native might be able to leverage some of this technology long term.

https://speakerdeck.com/lelandrichardson/react-meet-compose

React, Meet Compose

React Native has come to stay. There is so much excitement about developing native mobile applications using JavaScript. React Native has made it possible for web developers to develop sophisticated native mobile apps.

In the last two years, after building our React Native Apps, there are many things that I have learned the hard way. Lessons learned in coding standards, state management, supporting multiple platforms, release management, just to name a few.

In this session, I would share my experiences building React Native Apps, and the 10 things that I wish I knew early on. By the end of this talk, you will be equipped with best practices to follow while building your React Native App. Make sure you don’t repeat the same mistakes that I did.

https://adhithiravi.github.io/ChainReactTalk2019/#/

Building React Native Apps: 10 Things I've Learned On The Way

While Animations can be created in React Native pretty easily, real world mobile apps require a combination of several layers of animations, gestures and micro interaction animations to make user experience stand out. In this talk we will walk through the process from defining complex animation, to implementing it by going through all stages of animation creation process.

https://slides.com/vladimirnovick/demystifying-react-native-animations#/

Demystifying complex animations creation process in React Native

"At Nozbe, we share almost all component-level code between React for the web and React Native (both iOS and Android) — without ReactXP, react-native-web, or react-primitives!

Let me show you how we did this — from project setup, through shared infrastructure, all the way up to shared components and styling — and how you can achieve the same thing.

https://www.dropbox.com/s/dzaedyr0dzptoaj/SuccessfulCodeSharingStrategies-v1.1.pdf?dl=0

Successful Web & React Native Code Sharing Strategies

Make your React Native Apps Accessible

React Native CLI has been extracted out of the main repository a while ago, as a part of ongoing Lean Core effort. We have merged more than 100 PRs since then and the number is growing. We also shipped a ton of improvements with other exciting features on the roadmap. In this talk, I am going to give you an update where we are, what are the highlights from past few months and what you can expect from the future.

https://github.com/react-native-community/react-native-cli

The State of React Native Tooling

A useful metaphor for the React Native project is that of a huge ship. Operating such a vessel is a massive effort, that requires many people running back and forth the deck hoisting the sails and lowering the anchor - but also rowers, cooks, and skippers just to mention a few. During my two years on this journey, as a developer not working for FB, I've experienced and participated in the evolution of the project from a unique vantage point.

I could tell tales for days of the many seas we've been through, the high waves and the storms we've weathered - but one constant has been the help provided from other sailors like me, part of the community. The collaboration with the RN team allowed for increasingly more complex roles and projects to ship - and we are all but done.

So I want to raise a glass to these companions, and through my narration showcase what the community accomplished - and the new horizons we are steering towards.

https://speakerdeck.com/kelset/all-hands-on-deck-the-rn-community-experience

All Hands on Deck - The React Native Community Experience

As TypeScript continues it's gradual take over of the JavaScript world, you might be having some similar FOMO as myself:

“What will all my friends think of me if I'm not using TypeScript in my React Native project?” 
“Where do I even begin to convert this giant codebase to TypeScript?”
“What the #*$% even is TypeScript?”

Luckily, there is a solution! And it won't take you weeks to do!
This talk will show you all the steps involved in converting a React Native project to TypeScript, as well as many of the pitfalls and gotchas that you might encounter along the way. 

https://speakerdeck.com/amhinson/convert-a-react-native-project-to-typescript-in-10-minutes

Convert a React Native Project to Typescript in 10 Minutes

React Native Panel

While building a React Native app, you should think of scalability from the get-go. A native mobile app goes through a lot of different phases - deployment, internalization, component practices, handling assets, offline support, complex animations and a lot more. In this talk, I will go through some of the best practices you should consider from setting up a project, challenges most react native app faces to scalability. At the end of this talk, you will go home with practices you can apply to your projects and feel more confident doing so. 🚀

http://bit.ly/a11y-react-native

Beyond the React Native Benchmark

This talk is about my journey in building an app that will keep track of your gym life. One single codebase and React Native. Only one person making an app for both Android and iOS that goes from zero to production till seeing your gym buddy using it.

This talk is based in my popular Tweet https://twitter.com/ferrannp/status/1017477385422299136 and my passion in building apps as a hobby.

I plan to cover:

- Database-offline solution
- UI library & theme
- Orientation & multiple layouts support
- i18n
- Navigation & deep linking
- Accessibility & RTL support
- Premium features & monetization
- Release to store & beta releases

Repo: https://github.com/ferrannp/fithero

React Native - Case study: From an idea to the market

If you’ve built an app with React or React Native, chances are you’ve had to build at least one form. From profile screens to login pages, forms are unavoidable, and let’s be honest, they’re not very fun to build. 

For each field, you need to hold the value in the state of your component, implement onChange and onBlur handlers, implement validation… that makes for a lot of boilerplate, and that’s just for simple inputs. 

There are several libraries out there that attempt to simplify this process, from Redux Form, to React Form, to Formik, among others. In this talk, we’ll go over the existing solutions, how they stack up against each other, and what their limitations are.

https://speakerdeck.com/kirakik/lets-simplify-your-complex-forms

Let’s Simplify Your Complex Forms

Visual regressions in mobile applications can be serious problems and are notoriously tedious to catch. Hours, even days, can be spent manually sifting through screenshots of a mobile application before releasing it to real users. With automated screenshot testing, much of this tedium can be avoided, and mobile app developers can be empowered to iterate with confidence.

Screenshot Testing React Native Apps with Percy

React Native is advertised as a framework for developing native apps with javascript. However, developing Android apps requires more effort. This talk will look at the ways in which my team and I learned, sometimes the hard way, how to develop a react native app for Android, as well as my experience as a JavaScript developer being thrust into the native world.

Why Can't We Be Friends?

In a world where perpetually confused developers can’t quite get their React Native development environments working, new libraries emerge from the ashes of lost productivity: envinfo and Solidarity. Escape the complexity and be part of the wave of teams embracing change to save their projects from themselves.

https://speakerdeck.com/tabrindle/end-your-development-environment-nightmares-with-envinfo-and-solidarity

End Your Development Nightmares with envinfo and Solidarity

A brief exploration of decisions and difficulties encountered when employing third-party libraries in React Native applications, yielding actionable advice for open-source package maintainers in our community.

3rd Party Nightmares

Creating scalable and maintainable React Native app using Mobx State Tree

Slides: https://drive.google.com/file/d/1cBf1FFVewPSKI7TmMdrvsyk8NuYtxMUN/view
Repository: https://github.com/webmasterdevlin/mstdemo

Getting Started with Mobx Statetree

What is Expo, what have we been working on, and what’s up next? Give me your attention for half an hour and let me tell you about that.

https://www.icloud.com/keynote/0Jab6KBEszi8hWKJ8Ey-07Csg#chain-react

Expo for Everyone

Have you ever wanted to allow someone to provide feedback on your application without installing the package? Maybe you need to provide customer support for different devices. 

Bitrise is a pipeline tool that will pull from your repository and has multiple configurations that allow you to build for different purposes. One purpose is deploying to Appetize.io which allows for a fully interactive version of your application on multiple devices and platforms without much effort. This has allowed us to train our support reps, but also allow them to walk through a trouble ticket with users on the fly.

In this session I will demonstrate a basic setup of Bitrise to build the application for both iOS and Android platforms, with a deployment to Appetize for both versions.