diff --git a/blog/2015-03-26-react-native-bringing-modern-web-techniques-to-mobile.md b/blog/2015-03-26-react-native-bringing-modern-web-techniques-to-mobile.md
deleted file mode 100644
index 7fb0e11469960c..00000000000000
--- a/blog/2015-03-26-react-native-bringing-modern-web-techniques-to-mobile.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: React Native: Bringing modern web techniques to mobile
-author: Tom Occhino
-authorTitle: Engineering Manager at Facebook
-authorURL: https://github.com/tomocchino
-authorImage: https://avatars0.githubusercontent.com/u/13947?v=3&s=460
-authorTwitter: tomocchino
-hero: /react-native/blog/img/dark-hero.png
-category: announcements
----
-
-We introduced [React](https://code.facebook.com/projects/176988925806765/react/) to the world two years ago, and since then it's seen impressive growth, both inside and outside of Facebook. Today, even though no one is forced to use it, new web projects at Facebook are commonly built using React in one form or another, and it's being broadly adopted across the industry. Engineers are choosing to use React every day because it enables them to spend more time focusing on their products and less time fighting with their framework. It wasn't until we'd been building with React for a while, though, that we started to understand what makes it so powerful.
-
-React forces us to break our applications down into discrete components, each representing a single view. These components make it easier to iterate on our products, since we don't need to keep the entire system in our head in order to make changes to one part of it. More important, though, React wraps the DOM's mutative, imperative API with a declarative one, which raises the level of abstraction and simplifies the programming model. What we've found is that when we build with React, our code is a lot more predictable. This predictability makes it so we can iterate more quickly with confidence, and our applications are a lot more reliable as a result. Additionally, it's not only easier to scale our applications when they're built with React, but we've found it's also easier to scale the size of our teams themselves.
-
-Together with the rapid iteration cycle of the web, we've been able to build some awesome products with React, including many components of Facebook.com. Additionally, we've built amazing frameworks in JavaScript on top of React, like [Relay](https://facebook.github.io/react/blog/2015/02/20/introducing-relay-and-graphql.html), which allows us to greatly simplify our data fetching at scale. Of course, web is only part of the story. Facebook also has widely used Android and iOS apps, which are built on top of disjointed, proprietary technology stacks. Having to build our apps on top of multiple platforms has bifurcated our engineering organization, but that's only one of the things that makes native mobile application development hard.
-
-
-
-> This is an excerpt. Read the rest of the post on [Facebook Code](https://code.facebook.com/posts/1014532261909640/react-native-bringing-modern-web-techniques-to-mobile/).
diff --git a/blog/2015-09-14-react-native-for-android.md b/blog/2015-09-14-react-native-for-android.md
deleted file mode 100644
index e5b0c3d95f4f68..00000000000000
--- a/blog/2015-09-14-react-native-for-android.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: React Native for Android: How we built the first cross-platform React Native app
-author: Daniel Witte
-authorTitle: Software Engineer at Facebook
-authorURL: https://www.facebook.com/drwitte
-authorImage: https://scontent-sea1-1.xx.fbcdn.net/v/t1.0-1/c54.54.681.681/s160x160/20622_10100459314481893_1435252658_n.jpg?_nc_log=1&oh=7afdb6aaa02f320c4dd4749733140133&oe=59D77C28
-hero: /react-native/blog/img/blue-hero.jpg
-category: announcements
----
-
-Earlier this year, we introduced [React Native for iOS](https://code.facebook.com/posts/1014532261909640/react-native-bringing-modern-web-techniques-to-mobile/). React Native brings what developers are used to from React on the web — declarative self-contained UI components and fast development cycles — to the mobile platform, while retaining the speed, fidelity, and feel of native applications. Today, we're happy to release React Native for Android.
-
-At Facebook we've been using React Native in production for over a year now. Almost exactly a year ago, our team set out to develop the [Ads Manager app](https://www.facebook.com/business/news/ads-manager-app). Our goal was to create a new app to let the millions of people who advertise on Facebook manage their accounts and create new ads on the go. It ended up being not only Facebook's first fully React Native app but also the first cross-platform one. In this post, we'd like to share with you how we built this app, how React Native enabled us to move faster, and the lessons we learned.
-
-
-
-> This is an excerpt. Read the rest of the post on [Facebook Code](https://code.facebook.com/posts/1189117404435352/react-native-for-android-how-we-built-the-first-cross-platform-react-native-app/).
diff --git a/blog/2015-11-23-making-react-native-apps-accessible.md b/blog/2015-11-23-making-react-native-apps-accessible.md
deleted file mode 100644
index 37630c437e86ee..00000000000000
--- a/blog/2015-11-23-making-react-native-apps-accessible.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: Making React Native apps accessible
-author: Georgiy Kassabli
-authorTitle: Software Engineer at Facebook
-authorURL: https://www.facebook.com/georgiy.kassabli
-authorImage: https://scontent-sea1-1.xx.fbcdn.net/v/t1.0-1/c0.0.160.160/p160x160/1978838_795592927136196_1205041943_n.jpg?_nc_log=1&oh=d7a500fdece1250955a4d27b0a80fee2&oe=59E8165A
-hero: /react-native/blog/img/blue-hero.jpg
-category: engineering
----
-
-With the recent launch of React on web and React Native on mobile, we've provided a new front-end framework for developers to build products. One key aspect of building a robust product is ensuring that anyone can use it, including people who have vision loss or other disabilities. The Accessibility API for React and React Native enables you to make any React-powered experience usable by someone who may use assistive technology, like a screen reader for the blind and visually impaired.
-
-For this post, we're going to focus on React Native apps. We've designed the React Accessibility API to look and feel similar to the iOS and Android APIs. If you've developed accessible applications for the web, iOS, or Android before, you should feel comfortable with the framework and nomenclature of the React AX API. For instance, you can make a UI element _accessible_ (therefore exposed to assistive technology) and use _accessibilityLabel_ to provide a string description for the element:
-
-```
-
-```
-
-Let's walk through a slightly more involved application of the React AX API by looking at one of Facebook's own React-powered products: the **Ads Manager app**.
-
-
-
-> This is an excerpt. Read the rest of the post on [Facebook Code](https://code.facebook.com/posts/435862739941212/making-react-native-apps-accessible/).
diff --git a/blog/2016-03-24-introducing-hot-reloading.md b/blog/2016-03-24-introducing-hot-reloading.md
deleted file mode 100644
index d85ee82a03d751..00000000000000
--- a/blog/2016-03-24-introducing-hot-reloading.md
+++ /dev/null
@@ -1,214 +0,0 @@
----
-title: Introducing Hot Reloading
-author: Martín Bigio
-authorTitle: Software Engineer at Instagram
-authorURL: https://twitter.com/martinbigio
-authorImage: https://avatars3.githubusercontent.com/u/535661?v=3&s=128
-authorTwitter: martinbigio
-category: engineering
----
-
-React Native's goal is to give you the best possible developer experience. A big part of it is the time it takes between you save a file and be able to see the changes. Our goal is to get this feedback loop to be under 1 second, even as your app grows.
-
-We got close to this ideal via three main features:
-
-* Use JavaScript as the language doesn't have a long compilation cycle time.
-* Implement a tool called Packager that transforms es6/flow/jsx files into normal JavaScript that the VM can understand. It was designed as a server that keeps intermediate state in memory to enable fast incremental changes and uses multiple cores.
-* Build a feature called Live Reload that reloads the app on save.
-
-At this point, the bottleneck for developers is no longer the time it takes to reload the app but losing the state of your app. A common scenario is to work on a feature that is multiple screens away from the launch screen. Every time you reload, you've got to click on the same path again and again to get back to your feature, making the cycle multiple-seconds long.
-
-
-## Hot Reloading
-
-The idea behind hot reloading is to keep the app running and to inject new versions of the files that you edited at runtime. This way, you don't lose any of your state which is especially useful if you are tweaking the UI.
-
-A video is worth a thousand words. Check out the difference between Live Reload (current) and Hot Reload (new).
-
-
-
-If you look closely, you can notice that it is possible to recover from a red box and you can also start importing modules that were not previously there without having to do a full reload.
-
-**Word of warning:** because JavaScript is a very stateful language, hot reloading cannot be perfectly implemented. In practice, we found out that the current setup is working well for a large amount of usual use cases and a full reload is always available in case something gets messed up.
-
-Hot reloading is available as of 0.22, you can enable it:
-
-* Open the developer menu
-* Tap on "Enable Hot Reloading"
-
-
-## Implementation in a nutshell
-
-Now that we've seen why we want it and how to use it, the fun part begins: how it actually works.
-
-Hot Reloading is built on top of a feature [Hot Module Replacement](https://webpack.github.io/docs/hot-module-replacement-with-webpack.html), or HMR. It was first introduced by Webpack and we implemented it inside of React Native Packager. HMR makes the Packager watch for file changes and send HMR updates to a thin HMR runtime included on the app.
-
-In a nutshell, the HMR update contains the new code of the JS modules that changed. When the runtime receives them, it replaces the old modules' code with the new one:
-
-
-
-
-The HMR update contains a bit more than just the module's code we want to change because replacing it, it's not enough for the runtime to pick up the changes. The problem is that the module system may have already cached the *exports* of the module we want to update. For instance, say you have an app composed of these two modules:
-
-```
-// log.js
-function log(message) {
- const time = require('./time');
- console.log(`[${time()}] ${message}`);
-}
-
-module.exports = log;
-```
-
-```
-// time.js
-function time() {
- return new Date().getTime();
-}
-
-module.exports = time;
-```
-
-The module `log`, prints out the provided message including the current date provided by the module `time`.
-
-When the app is bundled, React Native registers each module on the module system using the `__d` function. For this app, among many `__d` definitions, there will one for `log`:
-
-```
-__d('log', function() {
- ... // module's code
-});
-```
-
-This invocation wraps each module's code into an anonymous function which we generally refer to as the factory function. The module system runtime keeps track of each module's factory function, whether it has already been executed, and the result of such execution (exports). When a module is required, the module system either provides the already cached exports or executes the module's factory function for the first time and saves the result.
-
-So say you start your app and require `log`. At this point, neither `log` nor `time`'s factory functions have been executed so no exports have been cached. Then, the user modifies `time` to return the date in `MM/DD`:
-
-```
-// time.js
-function bar() {
- var date = new Date();
- return `${date.getMonth() + 1}/${date.getDate()}`;
-}
-
-module.exports = bar;
-```
-
-The Packager will send time's new code to the runtime (step 1), and when `log` gets eventually required the exported function gets executed it will do so with `time`'s changes (step 2):
-
-
-
-
-Now say the code of `log` requires `time` as a top level require:
-
-```
-const time = require('./time'); // top level require
-
-// log.js
-function log(message) {
- console.log(`[${time()}] ${message}`);
-}
-
-module.exports = log;
-```
-
-When `log` is required, the runtime will cache its exports and `time`'s one. (step 1). Then, when `time` is modified, the HMR process cannot simply finish after replacing `time`'s code. If it did, when `log` gets executed, it would do so with a cached copy of `time` (old code).
-
-For `log` to pick up `time` changes, we'll need to clear its cached exports because one of the modules it depends on was hot swapped (step 3). Finally, when `log` gets required again, its factory function will get executed requiring `time` and getting its new code.
-
-
-
-
-## HMR API
-
-HMR in React Native extends the module system by introducing the `hot` object. This API is based on [Webpack](https://webpack.github.io/docs/hot-module-replacement.html)'s one. The `hot` object exposes a function called `accept` which allows you to define a callback that will be executed when the module needs to be hot swapped. For instance, if we would change `time`'s code as follows, every time we save time, we'll see “time changed” in the console:
-
-```
-// time.js
-function time() {
- ... // new code
-}
-
-module.hot.accept(() => {
- console.log('time changed');
-});
-
-module.exports = time;
-```
-
-Note that only in rare cases you would need to use this API manually. Hot Reloading should work out of the box for the most common use cases.
-
-## HMR Runtime
-
-As we've seen before, sometimes it's not enough only accepting the HMR update because a module that uses the one being hot swapped may have been already executed and its imports cached. For instance, suppose the dependency tree for the movies app example had a top-level `MovieRouter` that depended on the `MovieSearch` and `MovieScreen` views, which depended on the `log` and `time` modules from the previous examples:
-
-
-
-
-
-If the user accesses the movies' search view but not the other one, all the modules except for `MovieScreen` would have cached exports. If a change is made to module `time`, the runtime will have to clear the exports of `log` for it to pick up `time`'s changes. The process wouldn't finish there: the runtime will repeat this process recursively up until all the parents have been accepted. So, it'll grab the modules that depend on `log` and try to accept them. For `MovieScreen` it can bail, as it hasn't been required yet. For `MovieSearch`, it will have to clear its exports and process its parents recursively. Finally, it will do the same thing for `MovieRouter` and finish there as no modules depends on it.
-
-In order to walk the dependency tree, the runtime receives the inverse dependency tree from the Packager on the HMR update. For this example the runtime will receive a JSON object like this one:
-
-```
-{
- modules: [
- {
- name: 'time',
- code: /* time's new code */
- }
- ],
- inverseDependencies: {
- MovieRouter: [],
- MovieScreen: ['MovieRouter'],
- MovieSearch: ['MovieRouter'],
- log: ['MovieScreen', 'MovieSearch'],
- time: ['log'],
- }
-}
-```
-
-## React Components
-
-React components are a bit harder to get to work with Hot Reloading. The problem is that we can't simply replace the old code with the new one as we'd loose the component's state. For React web applications, [Dan Abramov](https://twitter.com/dan_abramov) implemented a babel [transform](https://gaearon.github.io/react-hot-loader/) that uses Webpack's HMR API to solve this issue. In a nutshell, his solution works by creating a proxy for every single React component on *transform time*. The proxies hold the component's state and delegate the lifecycle methods to the actual components, which are the ones we hot reload:
-
-
-
-Besides creating the proxy component, the transform also defines the `accept` function with a piece of code to force React to re-render the component. This way, we can hot reload rendering code without losing any of the app's state.
-
-The default [transformer](https://github.com/facebook/react-native/blob/master/packager/transformer.js#L92-L95) that comes with React Native uses the `babel-preset-react-native`, which is [configured](https://github.com/facebook/react-native/blob/master/babel-preset/configs/hmr.js#L24-L31) to use `react-transform` the same way you'd use it on a React web project that uses Webpack.
-
-## Redux Stores
-
-To enable Hot Reloading on [Redux](https://redux.js.org/) stores you will just need to use the HMR API similarly to what you'd do on a web project that uses Webpack:
-
-```
-// configureStore.js
-import { createStore, applyMiddleware, compose } from 'redux';
-import thunk from 'redux-thunk';
-import reducer from '../reducers';
-
-export default function configureStore(initialState) {
- const store = createStore(
- reducer,
- initialState,
- applyMiddleware(thunk),
- );
-
- if (module.hot) {
- module.hot.accept(() => {
- const nextRootReducer = require('../reducers/index').default;
- store.replaceReducer(nextRootReducer);
- });
- }
-
- return store;
-};
-```
-
-When you change a reducer, the code to accept that reducer will be sent to the client. Then the client will realize that the reducer doesn't know how to accept itself, so it will look for all the modules that refer it and try to accept them. Eventually, the flow will get to the single store, the `configureStore` module, which will accept the HMR update.
-
-## Conclusion
-
-If you are interested in helping making hot reloading better, I encourage you to read [Dan Abramov's post around the future of hot reloading](https://medium.com/@dan_abramov/hot-reloading-in-react-1140438583bf#.jmivpvmz4) and to contribute. For example, Johny Days is going to [make it work with multiple connected clients](https://github.com/facebook/react-native/pull/6179). We're relying on you all to maintain and improve this feature.
-
-With React Native, we have the opportunity to rethink the way we build apps in order to make it a great developer experience. Hot reloading is only one piece of the puzzle, what other crazy hacks can we do to make it better?
diff --git a/blog/2016-03-28-dive-into-react-native-performance.md b/blog/2016-03-28-dive-into-react-native-performance.md
deleted file mode 100644
index 629b83ea121ff4..00000000000000
--- a/blog/2016-03-28-dive-into-react-native-performance.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: Dive into React Native Performance
-author: Pieter De Baets
-authorTitle: Software Engineer at Facebook
-authorURL: https://github.com/javache
-authorImage: https://avatars1.githubusercontent.com/u/5676?v=3&s=460
-authorTwitter: javache
-category: engineering
----
-
-React Native allows you to build iOS and Android apps in JavaScript using React and Relay's declarative programming model. This leads to more concise, easier-to-understand code; fast iteration without a compile cycle; and easy sharing of code across multiple platforms. You can ship faster and focus on details that really matter, making your app look and feel fantastic. Optimizing performance is a big part of this. Here is the story of how we made React Native app startup twice as fast.
-
-## Why the hurry?
-
-With an app that runs faster, content loads quickly, which means people get more time to interact with it, and smooth animations make the app enjoyable to use. In emerging markets, where [2011 class phones](https://code.facebook.com/posts/952628711437136/classes-performance-and-network-segmentation-on-android/) on [2G networks](https://newsroom.fb.com/news/2015/10/news-feed-fyi-building-for-all-connectivity/) are the majority, a focus on performance can make the difference between an app that is usable and one that isn't.
-
-Since releasing React Native on [iOS](https://facebook.github.io/react/blog/2015/03/26/introducing-react-native.html) and on [Android](https://code.facebook.com/posts/1189117404435352/react-native-for-android-how-we-built-the-first-cross-platform-react-native-app/), we have been improving list view scrolling performance, memory efficiency, UI responsiveness, and app startup time. Startup sets the first impression of an app and stresses all parts of the framework, so it is the most rewarding and challenging problem to tackle.
-
-
-
-> This is an excerpt. Read the rest of the post on [Facebook Code](https://code.facebook.com/posts/895897210527114/dive-into-react-native-performance/).
diff --git a/blog/2016-04-13-react-native-a-year-in-review.md b/blog/2016-04-13-react-native-a-year-in-review.md
deleted file mode 100644
index afa84f28c84b60..00000000000000
--- a/blog/2016-04-13-react-native-a-year-in-review.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: React Native: A year in review
-author: Martin Konicek
-authorTitle: Software Engineer at Facebook
-authorURL: https://github.com/mkonicek
-authorImage: https://avatars1.githubusercontent.com/u/346214?v=3&s=460
-authorTwitter: martinkonicek
-hero: /react-native/blog/img/big-hero.jpg
-category: announcements
----
-
-It's been one year since we open-sourced React Native. What started as an idea with a handful of engineers is now a framework being used by product teams across Facebook and beyond. Today at F8 we announced that Microsoft is bringing [React Native to the Windows ecosystem](https://microsoft.github.io/code-push/articles/ReactNativeWindows.html), giving developers the potential to build React Native on Windows PC, Phone, and Xbox. It will also provide open source tools and services such as a React Native extension for Visual Studio Code and CodePush to help developers create React Native apps on the Windows platform. In addition, [Samsung](https://www.tizen.org/blogs) is building React Native for its hybrid platform, which will empower developers to build apps for millions of SmartTVs and mobile and wearable devices. We also released the [Facebook SDK for React Native](https://github.com/facebook/react-native-fbsdk), which makes it easier for developers to incorporate Facebook social features like Login, Sharing, App Analytics, and Graph APIs into their apps. In one year, React Native has changed the way developers build on every major platform.
-
-It's been an epic ride — but we are only getting started. Here is a look back at how React Native has grown and evolved since we open-sourced it a year ago, some challenges we faced along the way, and what we expect as we look ahead to the future.
-
-
-
-> This is an excerpt. Read the rest of the post on [Facebook Code](https://code.facebook.com/posts/597378980427792/react-native-a-year-in-review/).
diff --git a/blog/2016-07-06-toward-better-documentation.md b/blog/2016-07-06-toward-better-documentation.md
deleted file mode 100644
index 0f3c0f704ff4f4..00000000000000
--- a/blog/2016-07-06-toward-better-documentation.md
+++ /dev/null
@@ -1,69 +0,0 @@
----
-title: Toward Better Documentation
-author: Kevin Lacker
-authorTitle: Engineering Manager at Facebook
-authorURL: https://twitter.com/lacker
-authorImage: http://www.gravatar.com/avatar/9b790592be15d4f55a5ed7abb5103304?s=128
-authorTwitter: lacker
-category: announcements
----
-
-Part of having a great developer experience is having great documentation. A lot goes into creating good docs - the ideal documentation is concise, helpful, accurate, complete, and delightful. Recently we've been working hard to make the docs better based on your feedback, and we wanted to share some of the improvements we've made.
-
-## Inline Examples
-
-When you learn a new library, a new programming language, or a new framework, there's a beautiful moment when you first write a bit of code, try it out, see if it works... and it *does* work. You created something real. We wanted to put that visceral experience right into our docs. Like this:
-
-```ReactNativeWebPlayer
-import React, { Component } from 'react';
-import { AppRegistry, Text, View } from 'react-native';
-
-class ScratchPad extends Component {
- render() {
- return (
-
-
- Isn't this cool?
-
-
- 👍
-
-
- );
- }
-}
-
-AppRegistry.registerComponent('ScratchPad', () => ScratchPad);
-```
-
-We think these inline examples, using the [`react-native-web-player`](https://github.com/dabbott/react-native-web-player) module with help from [Devin Abbott](https://twitter.com/devinaabbott), are a great way to learn the basics of React Native, and we have updated our [tutorial for new React Native developers](/react-native/docs/tutorial.html) to use these wherever possible. Check it out - if you have ever been curious to see what would happen if you modified just one little bit of sample code, this is a really nice way to poke around. Also, if you're building developer tools and you want to show a live React Native sample on your own site, [`react-native-web-player`](https://github.com/dabbott/react-native-web-player) can make that straightforward.
-
-The core simulation engine is provided by [Nicolas Gallagher](https://twitter.com/necolas)'s [`react-native-web`](https://github.com/necolas/react-native-web) project, which provides a way to display React Native components like `Text` and `View` on the web. Check out [`react-native-web`](https://github.com/necolas/react-native-web) if you're interested in building mobile and web experiences that share a large chunk of the codebase.
-
-## Better Guides
-
-In some parts of React Native, there are multiple ways to do things, and we've heard feedback that we could provide better guidance.
-
-We have a new [guide to Navigation](/react-native/docs/navigator-comparison.html) that compares the different approaches and advises on what you should use - `Navigator`, `NavigatorIOS`, `NavigationExperimental`. In the medium term, we're working towards improving and consolidating those interfaces. In the short term, we hope that a better guide will make your life easier.
-
-We also have a new [guide to handling touches](/react-native/docs/handling-touches.html) that explains some of the basics of making button-like interfaces, and a brief summary of the different ways to handle touch events.
-
-Another area we worked on is Flexbox. This includes tutorials on how to [handle layout with Flexbox](/react-native/docs/flexbox.html) and how to control [the size of components](/react-native/docs/height-and-width.html). It also includes an unsexy but hopefully-useful [list of all the props that control layout in React Native](/react-native/docs/layout-props.html).
-
-## Getting Started
-
-When you start getting a React Native development environment set up on your machine, you do have to do a bunch of installing and configuring things. It's hard to make installation a really fun and exciting experience, but we can at least make it as quick and painless as possible.
-
-We built a [new Getting Started workflow](/react-native/releases/next/docs/getting-started.html) that lets you select your development operating system and your mobile operating system up front, to provide one concise place with all the setup instructions. We also went through the installation process to make sure everything worked and to make sure that every decision point had a clear recommendation. After testing it out on our innocent coworkers, we're pretty sure this is an improvement.
-
-We also worked on the [guide to integrating React Native into an existing app](/react-native/docs/integration-with-existing-apps.html). Many of the largest apps that use React Native, like the Facebook app itself, actually build part of the app in React Native, and part of it using regular development tools. We hope this guide makes it easier for more people to build apps this way.
-
-## We Need Your Help
-
-Your feedback lets us know what we should prioritize. I know some people will read this blog post and think "Better docs? Pffft. The documentation for X is still garbage!". That's great - we need that energy. The best way to give us feedback depends on the sort of feedback.
-
-If you find a mistake in the documentation, like inaccurate descriptions or code that doesn't actually work, [file an issue](https://github.com/facebook/react-native/issues). Tag it with "Documentation", so that it's easier to route it to the right people.
-
-If there isn't a specific mistake, but something in the documentation is fundamentally confusing, it's not a great fit for a GitHub issue. Instead, post on [Canny](https://react-native.canny.io/feature-requests) about the area of the docs that could use help. This helps us prioritize when we are doing more general work like guide-writing.
-
-Thanks for reading this far, and thanks for using React Native!
diff --git a/blog/2016-08-12-react-native-meetup-san-francisco.md b/blog/2016-08-12-react-native-meetup-san-francisco.md
deleted file mode 100644
index 0c36af6c47beda..00000000000000
--- a/blog/2016-08-12-react-native-meetup-san-francisco.md
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: San Francisco Meetup Recap
-author: Héctor Ramos
-authorTitle: Developer Advocate at Facebook
-authorURL: https://twitter.com/hectorramos
-authorImage: https://s.gravatar.com/avatar/f2223874e66e884c99087e452501f2da?s=128
-authorTwitter: hectorramos
-hero: /react-native/blog/img/rnmsf-august-2016-hero.jpg
-category: events
----
-
-Last week I had the opportunity to attend the [React Native Meetup](https://www.meetup.com/React-Native-San-Francisco/photos/27168649/#452793854) at Zynga’s San Francisco office. With around 200 people in attendance, it served as a great place to meet other developers near me that are also interested in React Native.
-
-I was particularly interested in learning more about how React and React Native are used at companies like Zynga, Netflix, and Airbnb. The agenda for the night would be as follows:
-
-* Rapid Prototyping in React
-* Designing APIs for React Native
-* Bridging the Gap: Using React Native in Existing Codebases
-
-But first, the event started off with a quick introduction and a brief recap of recent news:
-
-* Did you know that React Native is now the [top Java repository on GitHub](https://twitter.com/jamespearce/status/759637111880359937)?
-* [rnpm](https://github.com/rnpm/rnpm) is now part of React Native core! You can now use `react-native link` in place of `rnpm link` to [install libraries with native dependencies](https://facebook.github.io/react-native/docs/linking-libraries-ios.html).
-* The React Native Meetup community is growing fast! There are now over 4,800 developers across a variety of React Native meetup groups all over the globe.
-
-If [one of these meetups](https://www.meetup.com/find/?allMeetups=false&keywords=react+native&radius=Infinity&userFreeform=San+Francisco%2C+CA&mcId=z94105&mcName=San+Francisco%2C+CA&sort=recommended&eventFilter=mysugg) is held near you, I highly recommend attending!
-
-## Rapid Prototyping in React at Zynga
-
-The first round of news was followed by a quick introduction by Zynga, our hosts for the evening. Abhishek Chadha talked about how they use React to quickly prototype new experiences on mobile, demoing a quick prototype of a Draw Something-like app. They use a similar approach as React Native, providing access to native APIs via a bridge. This was demonstrated when Abhishek used the device's camera to snap a photo of the audience and then drew a hat on someone's head.
-
-## Designing APIs for React Native at Netflix
-
-Up next, the first featured talk of the evening. [Clarence Leung](https://twitter.com/clarler), Senior Software Engineer at Netflix, presented his talk on Designing APIs for React Native. First he noted the two main types of libraries one may work on: components such as tab bars and date pickers, and libraries that provide access to native services such as the camera roll or in-app payments. There are two ways one may approach when building a library for use in React Native:
-
-* Provide platform-specific components
-* A cross-platform library with a similar API for both iOS and Android
-
-Each approach has its own considerations, and it’s up to you to determine what works best for your needs.
-
-**Approach #1**
-
-As an example of platform-specific components, Clarence talked about the DatePickerIOS and DatePickerAndroid from core React Native. On iOS, date pickers are rendered as part of the UI and can be easily embedded in an existing view, while date pickers on Android are presented modally. It makes sense to provide separate components in this case.
-
-**Approach #2**
-
-Photo pickers, on the other hand, are treated similarly on iOS and Android. There are some slight differences — Android does not group photos into folders like iOS does with Selfies, for example — but those are easily handled using `if` statements and the `Platform` component.
-
-Regardless of which approach you settle on, it’s a good idea to minimize the API surface and build app-specific libraries. For example, iOS’s In-App Purchase framework supports one-time, consumable purchases, as well as renewable subscriptions. If your app will only need to support consumable purchases, you may get away with dropping support for subscriptions in your cross-platform library.
-
-
-
-There was a brief Q&A session at the end of Clarence’s talk. One of the interesting tid bits that came out of it was that around 80% of the React Native code written for these libraries at Netflix is shared across both iOS and Android.
-
-## Bridging the Gap, Using React Native in Existing Codebases
-
-The final talk of the night was by [Leland Richardson](https://twitter.com/intelligibabble) from Airbnb. The talk was focused on the use of React Native in existing codebases. I already know how easy it is to write a new app from scratch using React Native, so I was very interested to hear about Airbnb’s experience adopting React Native in their existing native apps.
-
-Leland started off by talking about greenfield apps versus brownfield apps. Greenfield means to start a project without the need to consider any prior work. This is in contrast to brownfield projects where you need to take into account the existing project’s requirements, development processes, and all of the teams various needs.
-
-When you’re working on a greenfield app, the React Native CLI sets up a single repository for both iOS and Android and everything just works. The first challenge against using React Native at Airbnb was the fact that the iOS and Android app each had their own repository. Multi-repo companies have some hurdles to get past before they can adopt React Native.
-
-To get around this, Airbnb first set up a new repo for the React Native codebase. They used their continuous integration servers to mirror the iOS and Android repos into this new repo. After tests are run and the bundle is built, the build artifacts are synced back to the iOS and Android repos. This allows the mobile engineers to work on native code without altering their development enviroment. Mobile engineers don't need to install npm, run the packager, or remember to build the JavaScript bundle. The engineers writing actual React Native code do not have to worry about syncing their code across iOS and Android, as they work on the React Native repository directly.
-
-This does come with some drawbacks, mainly they could not ship atomic updates. Changes that require a combination of native and JavaScript code would require three separate pull requests, all of which had to be carefully landed. In order to avoid conflicts, CI will fail to land changes back to the iOS and Android repos if master has changed since the build started. This would cause long delays during high commit frequency days (such as when new releases are cut).
-
-Airbnb has since moved to a mono repo approach. Fortunately this was already under consideration, and once the iOS and Android teams became comfortable with using React Native they were happy to accelerate the move towards the mono repo.
-
-This has solved most of the issues they had with the split repo approach. Leland did note that this does cause a higher strain on the version control servers, which may be an issue for smaller companies.
-
-
-
-### The Navigation Problem
-
-The second half of Leland's talk focused on a topic that is dear to me: the Navigation problem in React Native. He talked about the abundance of navigation libraries in React Native, both first party and third party. NavigationExperimental was mentioned as something that seemed promising, but ended up not being well suited for their use case.
-
-In fact, none of the existing navigation libraries seem to work well for brownfield apps. A brownfield app requires that the navigation state be fully owned by the native app. For example, if a user’s session expires while a React Native view is being presented, the native app should be able to take over and present a login screen as needed.
-
-Airbnb also wanted to avoid replacing native navigation bars with JavaScript versions as part of a transition, as the effect could be jarring. Initially they limited themselves to modally presented views, but this obviously presented a problem when it came to adopting React Native more widely within their apps.
-
-They decided that they needed their own library. The library is called `airbnb-navigation`. The library has not yet being open sourced as it is strongly tied to Airbnb’s codebase, but it is something they’d like to release by the end of the year.
-
-I won’t go into much detail into the library’s API, but here are some of the key takeaways:
-
-* One must preregister scenes ahead of time
-* Each scene is displayed within its own `RCTRootView`. They are presented natively on each platform (e.g. `UINavigationController`s are used on iOS).
-* The main `ScrollView` in a scene should be wrapped in a `ScrollScene` component. Doing so allows you to take advantage of native behaviors such as tapping on the status bar to scroll to the top on iOS.
-* Transitions between scenes are handled natively, no need to worry about performance.
-* The Android back button is automatically supported.
-* They can take advantage of View Controller based navigation bar styling via a Navigator.Config UI-less component.
-
-There’s also some considerations to keep in mind:
-
-* The navigation bar is not easily customized in JavaScript, as it is a native component. This is intentional, as using native navigation bars is a hard requirement for this type of library.
-* ScreenProps must be serialized/de-serialized whenever they're sent through the bridge, so care must be taken if sending too much data here.
-* Navigation state is owned by the native app (also a hard requirement for the library), so things like Redux cannot manipulate navigation state.
-
-Leland's talk was also followed by a Q&A session. Overall, Airbnb is satisfied with React Native. They’re interested in using Code Push to fix any issues without going through the App Store, and their engineers love Live Reload, as they don't have to wait for the native app to be rebuilt after every minor change.
-
-## Closing Remarks
-
-The event ended with some additional React Native news:
-
-* Deco announced their [React Native Showcase](https://www.decosoftware.com/showcase), and invited everyone to add their app to the list.
-* The recent [documentation overhaul](https://facebook.github.io/react-native/blog/2016/07/06/toward-better-documentation.html) got a shoutout!
-* Devin Abbott, one of the creators of Deco IDE, will be teaching an introductory [React Native course](https://www.decosoftware.com/course).
-
-
-
-Meetups provide a good opportunity to meet and learn from other developers in the community. I'm looking forward to attending more React Native meetups in the future. If you make it up to one of these, please look out for me and let me know how we can make React Native work better for you!
diff --git a/blog/2016-08-19-right-to-left-support-for-react-native-apps.md b/blog/2016-08-19-right-to-left-support-for-react-native-apps.md
deleted file mode 100644
index a59970d54c016a..00000000000000
--- a/blog/2016-08-19-right-to-left-support-for-react-native-apps.md
+++ /dev/null
@@ -1,220 +0,0 @@
----
-title: Right-to-Left Layout Support For React Native Apps
-author: Mengjue (Mandy) Wang
-authorTitle: Software Engineer Intern at Facebook
-authorURL: https://github.com/MengjueW
-authorImage: https://avatars0.githubusercontent.com/u/13987140?v=3&s=128
-category: engineering
----
-After launching an app to the app stores, internationalization is the next step to further your audience reach. Over 20 countries and numerous people around the world use Right-to-Left (RTL) languages. Thus, making your app support RTL for them is necessary.
-
-We're glad to announce that React Native has been improved to support RTL layouts. This is now available in the [react-native](https://github.com/facebook/react-native) master branch today, and will be available in the next RC: [`v0.33.0-rc`](https://github.com/facebook/react-native/releases).
-
-This involved changing [css-layout](https://github.com/facebook/css-layout), the core layout engine used by RN, and RN core implementation, as well as specific OSS JS components to support RTL.
-
-To battle test the RTL support in production, the latest version of the **Facebook Ads Manager** app (the first cross-platform 100% RN app) is now available in Arabic and Hebrew with RTL layouts for both [iOS](https://itunes.apple.com/app/id964397083) and [Android](https://play.google.com/store/apps/details?id=com.facebook.adsmanager). Here is how it looks like in those RTL languages:
-
-
-
-
-
-
-## Overview Changes in RN for RTL support
-[css-layout](https://github.com/facebook/css-layout) already has a concept of `start` and `end` for the layout. In the Left-to-Right (LTR) layout, `start` means `left`, and `end` means `right`. But in RTL, `start` means `right`, and `end` means `left`. This means we can make RN depend on the `start` and `end` calculation to compute the correct layout, which includes `position`, `padding`, and `margin`.
-
-In addition, [css-layout](https://github.com/facebook/css-layout) already makes each component's direction inherits from its parent. This means, we simply need to set the direction of the root component to RTL, and the entire app will flip.
-
-The diagram below describes the changes at high level:
-
-
-
-These include:
-
-* [css-layout RTL support for absolute positioning](https://github.com/facebook/css-layout/commit/46c842c71a1232c3c78c4215275d104a389a9a0f)
-* mapping `left` and `right` to `start` and `end` in RN core implementation for shadow nodes
-* and exposing a [bridged utility module](https://github.com/facebook/react-native/blob/f0fb228ec76ed49e6ed6d786d888e8113b8959a2/Libraries/Utilities/I18nManager.js) to help control the RTL layout
-
-With this update, when you allow RTL layout for your app:
-
-* every component layout will flip horizontally
-* some gestures and animations will automatically have RTL layout, if you are using RTL-ready OSS components
-* minimal additional effort may be needed to make your app fully RTL-ready
-
-## Making an App RTL-ready
-
-1. To support RTL, you should first add the RTL language bundles to your app.
- * See the general guides from [iOS](https://developer.apple.com/library/ios/documentation/MacOSX/Conceptual/BPInternational/LocalizingYourApp/LocalizingYourApp.html#//apple_ref/doc/uid/10000171i-CH5-SW1) and [Android](https://developer.android.com/training/basics/supporting-devices/languages.html).
-
-2. Allow RTL layout for your app by calling the `allowRTL()` function at the beginning of native code. We provided this utility to only apply to an RTL layout when your app is ready. Here is an example:
-
- iOS:
- ```objc
- // in AppDelegate.m
- [[RCTI18nUtil sharedInstance] allowRTL:YES];
- ```
-
- Android:
- ```java
- // in MainActivity.java
- I18nUtil sharedI18nUtilInstance = I18nUtil.getInstance();
- sharedI18nUtilInstance.allowRTL(context, true);
- ```
-
-3. For Android, you need add `android:supportsRtl="true"` to the [``](https://developer.android.com/guide/topics/manifest/application-element.html) element in `AndroidManifest.xml` file.
-
-Now, when you recompile your app and change the device language to an RTL language (e.g. Arabic or Hebrew), your app layout should change to RTL automatically.
-
-## Writing RTL-ready Components
-
-In general, most components are already RTL-ready, for example:
-
-* Left-to-Right Layout
-
-
-
-
-
-* Right-to-Left Layout
-
-
-
-
-
-However, there are several cases to be aware of, for which you will need the [`I18nManager`](https://github.com/facebook/react-native/blob/f0fb228ec76ed49e6ed6d786d888e8113b8959a2/Libraries/Utilities/I18nManager.js). In [`I18nManager`](https://github.com/facebook/react-native/blob/f0fb228ec76ed49e6ed6d786d888e8113b8959a2/Libraries/Utilities/I18nManager.js), there is a constant `isRTL` to tell if layout of app is RTL or not, so that you can make the necessary changes according to the layout.
-
-#### Icons with Directional Meaning
-If your component has icons or images, they will be displayed the same way in LTR and RTL layout, because RN will not flip your source image. Therefore, you should flip them according to the layout style.
-
-* Left-to-Right Layout
-
-
-
-
-
-* Right-to-Left Layout
-
-
-
-
-
-Here are two ways to flip the icon according to the direction:
-
-* Adding a `transform` style to the image component:
- ```js
-
- ```
-
-* Or, changing the image source according to the direction:
- ```js
- let imageSource = require('./back.png');
- if (I18nManager.isRTL) {
- imageSource = require('./forward.png');
- }
- return (
-
- );
- ```
-
-#### Gestures and Animations
-
-In iOS and Android development, when you change to RTL layout, the gestures and animations are the opposite of LTR layout. Currently, in RN, gestures and animations are not supported on RN core code level, but on components level. The good news is, some of these components already support RTL today, such as [`SwipeableRow`](https://github.com/facebook/react-native/blob/38a6eec0db85a5204e85a9a92b4dee2db9641671/Libraries/Experimental/SwipeableRow/SwipeableRow.js) and [`NavigationExperimental`](https://github.com/facebook/react-native/tree/master/Libraries/NavigationExperimental). However, other components with gestures will need to support RTL manually.
-
-A good example to illustrate gesture RTL support is [`SwipeableRow`](https://github.com/facebook/react-native/blob/38a6eec0db85a5204e85a9a92b4dee2db9641671/Libraries/Experimental/SwipeableRow/SwipeableRow.js).
-
-
-
-
-
-
-
-##### Gestures Example
-```js
-// SwipeableRow.js
-_isSwipingExcessivelyRightFromClosedPosition(gestureState: Object): boolean {
- // ...
- const gestureStateDx = IS_RTL ? -gestureState.dx : gestureState.dx;
- return (
- this._isSwipingRightFromClosed(gestureState) &&
- gestureStateDx > RIGHT_SWIPE_THRESHOLD
- );
-},
-```
-
-##### Animation Example
-```js
-// SwipeableRow.js
-_animateBounceBack(duration: number): void {
- // ...
- const swipeBounceBackDistance = IS_RTL ?
- -RIGHT_SWIPE_BOUNCE_BACK_DISTANCE :
- RIGHT_SWIPE_BOUNCE_BACK_DISTANCE;
- this._animateTo(
- -swipeBounceBackDistance,
- duration,
- this._animateToClosedPositionDuringBounce,
- );
-},
-```
-
-
-## Maintaining Your RTL-ready App
-
-Even after the initial RTL-compatible app release, you will likely need to iterate on new features. To improve development efficiency, [`I18nManager`](https://github.com/facebook/react-native/blob/f0fb228ec76ed49e6ed6d786d888e8113b8959a2/Libraries/Utilities/I18nManager.js) provides the `forceRTL()` function for faster RTL testing without changing the test device language. You might want to provide a simple switch for this in your app. Here's an example from the RTL example in the RNTester:
-
-
-
-
-
-```js
-
-
-
- forceRTL
-
-
-
-
-
-
-
-_onDirectionChange = () => {
- I18nManager.forceRTL(!this.state.isRTL);
- this.setState({isRTL: !this.state.isRTL});
- Alert.alert('Reload this page',
- 'Please reload this page to change the UI direction! ' +
- 'All examples in this app will be affected. ' +
- 'Check them out to see what they look like in RTL layout.'
- );
-};
-```
-
-When working on a new feature, you can easily toggle this button and reload the app to see RTL layout. The benefit is you won't need to change the language setting to test, however some text alignment won't change, as explained in the next section. Therefore, it's always a good idea to test your app in the RTL language before launching.
-
-## Limitations and Future Plan
-
-The RTL support should cover most of the UX in your app; however, there are some limitations for now:
-
-* Text alignment behaviors differ in iOS and Android
- * In iOS, the default text alignment depends on the active language bundle, they are consistently on one side. In Android, the default text alignment depends on the language of the text content, i.e. English will be left-aligned and Arabic will be right-aligned.
- * In theory, this should be made consistent across platform, but some people may prefer one behavior to another when using an app. More user experience research may be needed to find out the best practice for text alignment.
-
-
-* There is no "true" left/right
-
- As discussed before, we map the `left`/`right` styles from the JS side to `start`/`end`, all `left` in code for RTL layout becomes "right" on screen, and `right` in code becomes "left" on screen. This is convenient because you don't need to change your product code too much, but it means there is no way to specify "true left" or "true right" in the code. In the future, allowing a component to control its direction regardless of the language may be necessary.
-
-* Make RTL support for gestures and animations more developer friendly
-
- Currently, there is still some programming effort required to make gestures and animations RTL compatible.
- In the future, it would be ideal to find a way to make gestures and animations RTL support more developer friendly.
-
-## Try it Out!
-Check out the [`RTLExample`](https://github.com/facebook/react-native/blob/master/RNTester/js/RTLExample.js) in the `RNTester` to understand more about RTL support, and let us know how it works for you!
-
-Finally, thank you for reading! We hope that the RTL support for React Native helps you grow your apps for international audience!
diff --git a/blog/2016-09-08-exponent-talks-unraveling-navigation.md b/blog/2016-09-08-exponent-talks-unraveling-navigation.md
deleted file mode 100644
index 2d66764bd42377..00000000000000
--- a/blog/2016-09-08-exponent-talks-unraveling-navigation.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Expo Talks: Adam on Unraveling Navigation
-author: Héctor Ramos
-authorTitle: Developer Advocate at Facebook
-authorURL: https://twitter.com/hectorramos
-authorImage: https://s.gravatar.com/avatar/f2223874e66e884c99087e452501f2da?s=128
-authorTwitter: hectorramos
-youtubeVideoId: oeSjTxVkMhc
-category: videos
----
-
-[Adam Miskiewicz](https://twitter.com/skevy) from [Expo](https://expo.io/) talks about mobile navigation and the [`ex-navigation`](https://github.com/exponent/ex-navigation) React Native library at Expo's office hours last week.
diff --git a/blog/2016-10-25-0.36-headless-js-the-keyboard-api-and-more.md b/blog/2016-10-25-0.36-headless-js-the-keyboard-api-and-more.md
deleted file mode 100644
index 5f7480ed96015b..00000000000000
--- a/blog/2016-10-25-0.36-headless-js-the-keyboard-api-and-more.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-title: 0.36: Headless JS, the Keyboard API, & more
-author: Héctor Ramos
-authorTitle: Developer Advocate at Facebook
-authorURL: https://twitter.com/hectorramos
-authorImage: https://s.gravatar.com/avatar/f2223874e66e884c99087e452501f2da?s=128
-authorTwitter: hectorramos
-category: announcements
----
-
-Today we are releasing [React Native 0.36](https://github.com/facebook/react-native/releases/tag/v0.36.0). Read on to learn more about what's new.
-
-## Headless JS
-
-Headless JS is a way to run tasks in JavaScript while your app is in the background. It can be used, for example, to sync fresh data, handle push notifications, or play music. It is only available on Android, for now.
-
-To get started, define your async task in a dedicated file (e.g. `SomeTaskName.js`):
-
-```javascript
-module.exports = async (taskData) => {
- // Perform your task here.
-}
-```
-
-Next, register your task in on `AppRegistry`:
-
-```javascript
-AppRegistry.registerHeadlessTask('SomeTaskName', () => require('SomeTaskName'));
-```
-
-Using Headless JS does require some native Java code to be written in order to allow you to start up the service when needed. Take a look at our new [Headless JS docs](/react-native/docs/headless-js-android.html) to learn more!
-
-## The Keyboard API
-
-Working with the on-screen keyboard is now easier with [`Keyboard`](/react-native/docs/keyboard.html). You can now listen for native keyboard events and react to them. For example, to dismiss the active keyboard, simply call `Keyboard.dismiss()`:
-
-```js
-import { Keyboard } from 'react-native'
-
-// Hide that keyboard!
-Keyboard.dismiss()
-```
-
-## Animated Division
-
-Combining two animated values via addition, multiplication, and modulo are already supported by React Native. With version 0.36, combining two [animated values via division](/react-native/docs/animated.html#divide) is now possible. There are some cases where an animated value needs to invert another animated value for calculation. An example is inverting a scale (2x --> 0.5x):
-
-```
-const a = Animated.Value(1);
-const b = Animated.divide(1, a);
-
-Animated.spring(a, {
- toValue: 2,
-}).start();
-```
-
-`b` will then follow `a`'s spring animation and produce the value of `1 / a`.
-
-The basic usage is like this:
-
-```
-
-
-
-```
-
-In this example, the inner image won't get stretched at all because the parent's scaling gets cancelled out. If you'd like to learn more, check out the [Animations guide](/react-native/docs/animations.html).
-
-## Dark Status Bars
-
-A new `barStyle` value has been added to `StatusBar`: `dark-content`. With this addition, you can now use [`barStyle`](/react-native/docs/statusbar.html#barstyle) on both iOS and Android. The behavior will now be the following:
-
-- `default`: Use the platform default (light on iOS, dark on Android).
-- `light-content`: Use a light status bar with black text and icons.
-- `dark-content`: Use a dark status bar with white text and icons.
-
-## ...and more
-
-The above is just a sample of what has changed in 0.36. Check out the [release notes on GitHub](https://github.com/facebook/react-native/releases/tag/v0.36.0) to see the full list of new features, bug fixes, and breaking changes.
-
-You can upgrade to 0.36 by running the following commands in a terminal:
-
-```bash
-$ npm install --save react-native@0.36
-$ react-native upgrade
-```
diff --git a/blog/2016-11-08-introducing-button-yarn-and-a-public-roadmap.md b/blog/2016-11-08-introducing-button-yarn-and-a-public-roadmap.md
deleted file mode 100644
index a156e1900e7c75..00000000000000
--- a/blog/2016-11-08-introducing-button-yarn-and-a-public-roadmap.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: Introducing Button, Faster Installs with Yarn, and a Public Roadmap
-author: Héctor Ramos
-authorTitle: Developer Advocate at Facebook
-authorURL: https://twitter.com/hectorramos
-authorImage: https://s.gravatar.com/avatar/f2223874e66e884c99087e452501f2da?s=128
-authorTwitter: hectorramos
-category: announcements
----
-
-We have heard from many people that there is so much work happening with React Native, it can be tough to keep track of what's going on. To help communicate what work is in progress, we are now publishing a [roadmap for React Native](https://github.com/facebook/react-native/wiki/Roadmap). At a high level, this work can be broken down into three priorities:
-
-- **Core Libraries**. Adding more functionality to the most useful components and APIs.
-- **Stability**. Improve the underlying infrastructure to reduce bugs and improve code quality.
-- **Developer Experience**. Help React Native developers move faster
-
-If you have suggestions for features that you think would be valuable on the roadmap, check out [Canny](https://react-native.canny.io/feature-requests), where you can suggest new features and discuss existing proposals.
-
-## What's new in React Native
-
-[Version 0.37 of React Native](https://github.com/facebook/react-native/releases/tag/v0.37.0), released today, introduces a new core component to make it really easy to add a touchable Button to any app. We're also introducing support for the new [Yarn](https://yarnpkg.com/) package manager, which should speed up the whole process of updating your app's dependencies.
-
-## Introducing Button
-
-Today we're introducing a basic `` component that looks great on every platform. This addresses one of the most common pieces of feedback we get: React Native is one of the only mobile development toolkits without a button ready to use out of the box.
-
-
-
-```
-
-```
-
-Experienced React Native developers know how to make a button: use TouchableOpacity for the default look on iOS, TouchableNativeFeedback for the ripple effect on Android, then apply a few styles. Custom buttons aren't particularly hard to build or install, but we aim to make React Native radically easy to learn. With the addition of a basic button into core, newcomers will be able to develop something awesome in their first day, rather than spending that time formatting a Button and learning about Touchable nuances.
-
-Button is meant to work great and look native on every platform, so it won't support all the bells and whistles that custom buttons do. It is a great starting point, but is not meant to replace all your existing buttons. To learn more, check out the [new Button documentation](https://facebook.github.io/react-native/docs/button.html), complete with a runnable example!
-
-
-## Speed up `react-native init` using Yarn
-
-You can now use [Yarn](https://yarnpkg.com/), the new package manager for JavaScript, to speed up `react-native init` significantly. To see the speedup please [install yarn](https://yarnpkg.com/en/docs/install) and upgrade your `react-native-cli` to 1.2.0:
-
-```
-$ npm install -g react-native-cli
-```
-
-You should now see “Using yarn” when setting up new apps:
-
-
-
-In simple local testing `react-native init` finished in **about 1 minute on a good network** (vs around 3 minutes when using npm 3.10.8). Installing yarn is optional but highly recommended.
-
-## Thank you!
-
-We'd like to thank everyone who contributed to this release. The full [release notes](https://github.com/facebook/react-native/releases/tag/v0.37.0) are now available on GitHub. With over two dozen bug fixes and new features, React Native just keeps getting better thanks to you.
diff --git a/blog/2016-12-05-easier-upgrades.md b/blog/2016-12-05-easier-upgrades.md
deleted file mode 100644
index d87ec28c478b74..00000000000000
--- a/blog/2016-12-05-easier-upgrades.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: Easier Upgrades Thanks to Git
-author: Nicolas Cuillery
-authorTitle: JavaScript consultant and trainer at Zenika
-authorURL: https://twitter.com/ncuillery
-authorImage: https://fr.gravatar.com/userimage/78328995/184460def705a160fd8edadc04f60eaf.jpg?size=128
-authorTwitter: ncuillery
-category: announcements
----
-
-Upgrading to new versions of React Native has been difficult. You might have seen something like this before:
-
-
-
-None of those options is ideal. By overwriting the file we lose our local changes. By not overwriting we don't get the latest updates.
-
-Today I am proud to introduce a new tool that helps solve this problem. The tool is called `react-native-git-upgrade` and uses Git behind the scenes to resolve conflicts automatically whenever possible.
-
-## Usage
-
-> **Requirement**: Git has to be available in the `PATH`. Your project doesn't have to be managed by Git.
-
-Install `react-native-git-upgrade` globally:
-
-```shell
-$ npm install -g react-native-git-upgrade
-```
-or, using [Yarn](https://yarnpkg.com/):
-
-```shell
-$ yarn global add react-native-git-upgrade
-```
-
-Then, run it inside your project directory:
-
-```shell
-$ cd MyProject
-$ react-native-git-upgrade 0.38.0
-```
-
-> Note: Do **not** run 'npm install' to install a new version of `react-native`. The tool needs to be able to compare the old and new project template to work correctly. Simply run it inside your app folder as shown above, while still on the old version.
-
-Example output:
-
-
-
-You can also run `react-native-git-upgrade` with no arguments to upgrade to the latest version of React Native.
-
-We try to preserve your changes in iOS and Android build files, so you don't need to run `react-native link` after an upgrade.
-
-We have designed the implementation to be as little intrusive as possible. It is entirely based on a local Git repository created on-the-fly in a temporary directory. It won't interfere with your project repository (no matter what VCS you use: Git, SVN, Mercurial, ... or none). Your sources are restored in case of unexpected errors.
-
-## How does it work?
-
-The key step is generating a Git patch. The patch contains all the changes made in the React Native templates between the version your app is using and the new version.
-
-To obtain this patch, we need to generate an app from the templates embedded in the `react-native` package inside your `node_modules` directory (these are the same templates the `react-native init` commands uses). Then, after the native apps have been generated from the templates in both the current version and the new version, Git is able to produce a patch that is adapted to your project (i.e. containing your app name):
-
-```
-[...]
-
-diff --git a/ios/MyAwesomeApp/Info.plist b/ios/MyAwesomeApp/Info.plist
-index e98ebb0..2fb6a11 100644
---- a/ios/MyAwesomeApp/Info.plist
-+++ b/ios/MyAwesomeApp/Info.plist
-@@ -45,7 +45,7 @@
-
- localhost
-
-- NSTemporaryExceptionAllowsInsecureHTTPLoads
-+ NSExceptionAllowsInsecureHTTPLoads
-
-
-
-[...]
-```
-
-All we need now is to apply this patch to your source files. While the old `react-native upgrade` process would have prompted you for any small difference, Git is able to merge most of the changes automatically using its 3-way merge algorithm and eventually leave us with familiar conflict delimiters:
-
-```
- 13B07F951A680F5B00A75B9A /* Release */ = {
- isa = XCBuildConfiguration;
- buildSettings = {
- ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-<<<<<<< ours
- CODE_SIGN_IDENTITY = "iPhone Developer";
- FRAMEWORK_SEARCH_PATHS = (
- "$(inherited)",
- "$(PROJECT_DIR)/HockeySDK.embeddedframework",
- "$(PROJECT_DIR)/HockeySDK-iOS/HockeySDK.embeddedframework",
- );
-=======
- CURRENT_PROJECT_VERSION = 1;
->>>>>>> theirs
- HEADER_SEARCH_PATHS = (
- "$(inherited)",
- /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
- "$(SRCROOT)/../node_modules/react-native/React/**",
- "$(SRCROOT)/../node_modules/react-native-code-push/ios/CodePush/**",
- );
-```
-
-These conflicts are generally easy to reason about. The delimiter **ours** stands for "your team" whereas **theirs** could be seen as "the React Native team".
-
-## Why introduce a new global package?
-
-React Native comes with a global CLI (the [react-native-cli](https://www.npmjs.com/package/react-native-cli) package) which delegates commands to the local CLI embedded in the `node_modules/react-native/local-cli` directory.
-
-As we mentioned above, the process has to be started from your current React Native version. If we had embedded the implementation in the local-cli, you wouldn't be able to enjoy this feature when using old versions of React Native. For example, you wouldn't be able to upgrade from 0.29.2 to 0.38.0 if this new upgrade code was only released in 0.38.0.
-
-Upgrading based on Git is a big improvement in developer experience and it is important to make it available to everyone. By using a separate package [react-native-git-upgrade](https://www.npmjs.com/package/react-native-git-upgrade) installed globally you can use this new code today no matter what version of React Native your project is using.
-
-One more reason is the recent [Yeoman wipeout](https://twitter.com/martinkonicek/status/800730190141857793) by Martin Konicek. We didn't want to get these Yeoman dependencies back into the `react-native` package to be able to evaluate the old template in order to create the patch.
-
-## Try it out and provide feedback
-
-As a conclusion, I would say, enjoy the feature and feel free [to suggest improvements, report issues](https://github.com/facebook/react-native/issues) and especially [send pull requests](https://github.com/facebook/react-native/pulls). Each environment is a bit different and each React Native project is different, and we need your feedback to make this work well for everyone.
-
-### Thank you!
-
-I would like to thank the awesome companies [Zenika](https://www.zenika.com) and [M6 Web](http://www.groupem6.fr/le-groupe_en/activites/diversifications/m6-web.html) without whom none of this would have been possible!
diff --git a/blog/2017-01-07-monthly-release-cadence.md b/blog/2017-01-07-monthly-release-cadence.md
deleted file mode 100644
index 1ffc1c85091c3c..00000000000000
--- a/blog/2017-01-07-monthly-release-cadence.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: A Monthly Release Cadence: Releasing December and January RC
-author: Eric Vicenti
-authorTitle: Engineer at Facebook
-authorURL: https://twitter.com/EricVicenti
-authorImage: https://secure.gravatar.com/avatar/077ad5372b65567fe952a99f3b627048?s=128
-authorTwitter: EricVicenti
-category: announcements
----
-
-Shortly after React Native was introduced, we started releasing every two weeks to help the community adopt new features, while keeping versions stable for production use. At Facebook we had to stabilize the codebase every two weeks for the release of our production iOS apps, so we decided to release the open source versions at the same pace. Now, many of the Facebook apps ship once per week, especially on Android. Because we ship from master weekly, we need to keep it quite stable. So the bi-weekly release cadence doesn't even benefit internal contributors anymore.
-
-We frequently hear feedback from the community that the release rate is hard to keep up with. Tools like [Expo](https://expo.io/) had to skip every other release in order to manage the rapid change in version. So it seems clear that the bi-weekly releases did not serve the community well.
-
-### Now releasing monthly
-
-We're happy to announce the new monthly release cadence, and the December 2016 release, `v0.40`, which has been stabilizing for all last month and is ready to adopt. (Just make sure to [update headers in your native modules on iOS](https://github.com/facebook/react-native/releases/tag/v0.40.0)).
-
-Although it may vary a few days to avoid weekends or handle unforeseen issues, you can now expect a given release to be available on the first day of the month, and released on the last.
-
-### Use the current month for the best support
-
-The January release candidate is ready to try, and you can [see what's new here](https://github.com/facebook/react-native/releases/tag/v0.41.0-rc.0).
-
-To see what changes are coming and provide better feedback to React Native contributors, always use the current month's release candidate when possible. By the time each version is released at the end of the month, the changes it contains will have been shipped in production Facebook apps for over two weeks.
-
-You can easily upgrade your app with the new [react-native-git-upgrade](https://facebook.github.io/react-native/blog/2016/12/05/easier-upgrades.html) command:
-
-```
-npm install -g react-native-git-upgrade
-react-native-git-upgrade 0.41.0-rc.0
-```
-
-We hope this simpler approach will make it easier for the community to keep track of changes in React Native, and to adopt new versions as quickly as possible!
-
-(Thanks go to [Martin Konicek](https://github.com/mkonicek) for coming up with this plan and [Mike Grabowski](https://github.com/grabbou) for making it happen)
diff --git a/blog/2017-02-14-using-native-driver-for-animated.md b/blog/2017-02-14-using-native-driver-for-animated.md
deleted file mode 100644
index 9c577f809b0aa8..00000000000000
--- a/blog/2017-02-14-using-native-driver-for-animated.md
+++ /dev/null
@@ -1,158 +0,0 @@
----
-title: Using Native Driver for Animated
-author: Janic Duplessis
-authorTitle: Software Engineer at App & Flow
-authorURL: https://twitter.com/janicduplessis
-authorImage: https://secure.gravatar.com/avatar/8d6b6c0f5b228b0a8566a69de448b9dd?s=128
-authorTwitter: janicduplessis
-category: engineering
----
-
-For the past year, we've been working on improving performance of animations that use the Animated library. Animations are very important to create a beautiful user experience but can also be hard to do right. We want to make it easy for developers to create performant animations without having to worry about some of their code causing it to lag.
-
-## What is this?
-
-The Animated API was designed with a very important constraint in mind, it is serializable. This means we can send everything about the animation to native before it has even started and allows native code to perform the animation on the UI thread without having to go through the bridge on every frame. It is very useful because once the animation has started, the JS thread can be blocked and the animation will still run smoothly. In practice this can happen a lot because user code runs on the JS thread and React renders can also lock JS for a long time.
-
-## A bit of history...
-
-This project started about a year ago, when Expo built the li.st app on Android. [Krzysztof Magiera](https://twitter.com/kzzzf) was contracted to build the initial implementation on Android. It ended up working well and li.st was the first app to ship with native driven animations using Animated. A few months later, [Brandon Withrow](https://github.com/buba447) built the initial implementation on iOS. After that, [Ryan Gomba](https://twitter.com/ryangomba) and myself worked on adding missing features like support for `Animated.event` as well as squash bugs we found when using it in production apps. This was truly a community effort and I would like to thanks everyone that was involved as well as Expo for sponsoring a large part of the development. It is now used by `Touchable` components in React Native as well as for navigation animations in the newly released [React Navigation](https://github.com/react-community/react-navigation) library.
-
-## How does it work?
-
-First, let's check out how animations currently work using Animated with the JS driver. When using Animated, you declare a graph of nodes that represent the animations that you want to perform, and then use a driver to update an Animated value using a predefined curve. You may also update an Animated value by connecting it to an event of a `View` using `Animated.event`.
-
-
-
-Here's a breakdown of the steps for an animation and where it happens:
-
-- JS: The animation driver uses `requestAnimationFrame` to execute on every frame and update the value it drives using the new value it calculates based on the animation curve.
-- JS: Intermediate values are calculated and passed to a props node that is attached to a `View`.
-- JS: The `View` is updated using `setNativeProps`.
-- JS to Native bridge.
-- Native: The `UIView` or `android.View` is updated.
-
-As you can see, most of the work happens on the JS thread. If it is blocked the animation will skip frames. It also needs to go through the JS to Native bridge on every frame to update native views.
-
-What the native driver does is move all of these steps to native. Since Animated produces a graph of animated nodes, it can be serialized and sent to native only once when the animation starts, eliminating the need to callback into the JS thread; the native code can take care of updating the views directly on the UI thread on every frame.
-
-Here's an example of how we can serialize an animated value and an interpolation node (not the exact implementation, just an example).
-
-Create the native value node, this is the value that will be animated:
-```
-NativeAnimatedModule.createNode({
- id: 1,
- type: 'value',
- initialValue: 0,
-});
-```
-
-Create the native interpolation node, this tells the native driver how to interpolate a value:
-```
-NativeAnimatedModule.createNode({
- id: 2,
- type: 'interpolation',
- inputRange: [0, 10],
- outputRange: [10, 0],
- extrapolate: 'clamp',
-});
-```
-
-Create the native props node, this tells the native driver which prop on the view it is attached to:
-```
-NativeAnimatedModule.createNode({
- id: 3,
- type: 'props',
- properties: ['style.opacity'],
-});
-```
-
-Connect nodes together:
-```
-NativeAnimatedModule.connectNodes(1, 2);
-NativeAnimatedModule.connectNodes(2, 3);
-```
-
-Connect the props node to a view:
-```
-NativeAnimatedModule.connectToView(3, ReactNative.findNodeHandle(viewRef));
-```
-
-With that, the native animated module has all the info it needs to update the native views directly without having to go to JS to calculate any value.
-
-All there is left to do is actually start the animation by specifying what type of animation curve we want and what animated value to update. Timing animations can also be simplified by calculating every frame of the animation in advance in JS to make the native implementation smaller.
-```
-NativeAnimatedModule.startAnimation({
- type: 'timing',
- frames: [0, 0.1, 0.2, 0.4, 0.65, ...],
- animatedValueId: 1,
-});
-```
-
-And now here's the breakdown of what happens when the animation runs:
-
-- Native: The native animation driver uses `CADisplayLink` or `android.view.Choreographer` to execute on every frame and update the value it drives using the new value it calculates based on the animation curve.
-- Native: Intermediate values are calculated and passed to a props node that is attached to a native view.
-- Native: The `UIView` or `android.View` is updated.
-
-As you can see, no more JS thread and no more bridge which means faster animations! 🎉🎉
-
-## How do I use this in my app?
-
-For normal animations the answer is simple, just add `useNativeDriver: true` to the animation config when starting it.
-
-Before:
-```
-Animated.timing(this.state.animatedValue, {
- toValue: 1,
- duration: 500,
-}).start();
-```
-After:
-```
-Animated.timing(this.state.animatedValue, {
- toValue: 1,
- duration: 500,
- useNativeDriver: true, // <-- Add this
-}).start();
-```
-
-Animated values are only compatible with one driver so if you use native driver when starting an animation on a value, make sure every animation on that value also uses the native driver.
-
-It also works with `Animated.event`, this is very useful if you have an animation that must follow the scroll position because without the native driver it will always run a frame behind of the gesture because of the async nature of React Native.
-
-Before:
-```
-
- {content}
-
-```
-After:
-```
-
- {content}
-
-```
-
-## Caveats
-
-Not everything you can do with Animated is currently supported in Native Animated. The main limitation is that you can only animate non-layout properties, things like `transform` and `opacity` will work but flexbox and position properties won't. Another one is with `Animated.event`, it will only work with direct events and not bubbling events. This means it does not work with `PanResponder` but does work with things like `ScrollView#onScroll`.
-
-Native Animated has also been part of React Native for quite a while but has never been documented because it was considered experimental. Because of that make sure you are using a recent version (0.40+) of React Native if you want to use this feature.
-
-## Resources
-
-For more information about animated I recommend watching [this talk](https://www.youtube.com/watch?v=xtqUJVqpKNo) by [Christopher Chedeau](https://twitter.com/Vjeux).
-
-If you want a deep dive into animations and how offloading them to native can improve user experience there is also [this talk](https://www.youtube.com/watch?v=qgSMjYWqBk4) by [Krzysztof Magiera](https://twitter.com/kzzzf).
diff --git a/blog/2017-03-13-better-list-views.md b/blog/2017-03-13-better-list-views.md
deleted file mode 100644
index bf195cd78ef0df..00000000000000
--- a/blog/2017-03-13-better-list-views.md
+++ /dev/null
@@ -1,120 +0,0 @@
----
-title: Better List Views in React Native
-author: Spencer Ahrens
-authorTitle: Software Engineer at Facebook
-authorURL: https://github.com/sahrens
-authorImage: https://avatars1.githubusercontent.com/u/1509831
-authorTwitter: sahrens2012
-category: engineering
----
-
-Many of you have started playing with some of our new List components already after our [teaser announcement in the community group](https://www.facebook.com/groups/react.native.community/permalink/921378591331053), but we are officially announcing them today! No more `ListView`s or `DataSource`s, stale rows, ignored bugs, or excessive memory consumption - with the latest React Native March 2017 release candidate (`0.43-rc.1`) you can pick from the new suite of components what best fits your use-case, with great perf and feature sets out of the box:
-
-### [``](https://facebook.github.io/react-native/releases/next/docs/flatlist.html) ###
-
-This is the workhorse component for simple, performant lists. Provide an array of data and a `renderItem` function and you're good to go:
-
-```
-}
-/>
-```
-
-### [``](https://facebook.github.io/react-native/releases/next/docs/sectionlist.html) ###
-
-If you want to render a set of data broken into logical sections, maybe with section headers (e.g. in an alphabetical address book), and potentially with heterogeneous data and rendering (such as a profile view with some buttons followed by a composer, then a photo grid, then a friend grid, and finally a list of stories), this is the way to go.
-
-```
-}
- renderSectionHeader={({section}) => }
- sections={[ // homogeneous rendering between sections
- {data: [...], key: ...},
- {data: [...], key: ...},
- {data: [...], key: ...},
- ]}
-/>
-
-
-```
-
-### [``](https://facebook.github.io/react-native/releases/next/docs/virtualizedlist.html) ##
-
-The implementation behind the scenes with a more flexible API. Especially handy if your data is not in a plain array (e.g. an immutable list).
-
-## Features ##
-
-Lists are used in many contexts, so we packed the new components full of features to handle the majority of use cases out of the box:
-
-* Scroll loading (`onEndReached`).
-* Pull to refresh (`onRefresh` / `refreshing`).
-* [Configurable](https://github.com/facebook/react-native/blob/master/Libraries/CustomComponents/Lists/ViewabilityHelper.js) viewability (VPV) callbacks (`onViewableItemsChanged` / `viewabilityConfig`).
-* Horizontal mode (`horizontal`).
-* Intelligent item and section separators.
-* Multi-column support (`numColumns`)
-* `scrollToEnd`, `scrollToIndex`, and `scrollToItem`
-* Better Flow typing.
-
-### Some Caveats ###
-
-- The internal state of item subtrees is not preserved when content scrolls out of the render window. Make sure all your data is captured in the item data or external stores like Flux, Redux, or Relay.
-
-- These components are based on `PureComponent` which means that they will not re-render if `props` remains shallow-equal. Make sure that everything your `renderItem` function depends on directly is passed as a prop that is not `===` after updates, otherwise your UI may not update on changes. This includes the `data` prop and parent component state. For example:
-
- ```javascript
- this.setState((oldState) => ({
- selected: { // New instance breaks `===`
- ...oldState.selected, // copy old data
- [item.key]: !oldState.selected[item.key], // toggle
- }}))
- }
- selected={
- !!this.state.selected[item.key] // renderItem depends on state
- }
- />}
- selected={ // Can be any prop that doesn't collide with existing props
- this.state.selected // A change to selected should re-render FlatList
- }
- />
- ```
-
-- In order to constrain memory and enable smooth scrolling, content is rendered asynchronously offscreen. This means it's possible to scroll faster than the fill rate and momentarily see blank content. This is a tradeoff that can be adjusted to suit the needs of each application, and we are working on improving it behind the scenes.
-
-- By default, these new lists look for a `key` prop on each item and use that for the React key. Alternatively, you can provide a custom `keyExtractor` prop.
-
-## Performance ##
-
-Besides simplifying the API, the new list components also have significant performance enhancements, the main one being nearly constant memory usage for any number of rows. This is done by 'virtualizing' elements that are outside of the render window by completely unmounting them from the component hierarchy and reclaiming the JS memory from the react components, along with the native memory from the shadow tree and the UI views. This has a catch which is that internal component state will not be preserved, so **make sure you track any important state outside of the components themselves, e.g. in Relay or Redux or Flux store.**
-
-Limiting the render window also reduces the amount of work that needs to be done by React and the native platform, e.g from view traversals. Even if you are rendering the last of a million elements, with these new lists there is no need to iterate through all those elements in order to render. You can even jump to the middle with `scrollToIndex` without excessive rendering.
-
-We've also made some improvements with scheduling which should help with application responsiveness. Items at the edge of the render window are rendered infrequently and at a lower priority after any active gestures or animations or other interactions have completed.
-
-## Advanced Usage ##
-
-Unlike `ListView`, all items in the render window are re-rendered any time any props change. Often this is fine because the windowing reduces the number of items to a constant number, but if your items are on the complex side, you should make sure to follow React best practices for performance and use `React.PureComponent` and/or `shouldComponentUpdate` as appropriate within your components to limit re-renders of the recursive subtree.
-
-If you can calculate the height of your rows without rendering them, you can improve the user experience by providing the `getItemLayout` prop. This makes it much smoother to scroll to specific items with e.g. `scrollToIndex`, and will improve the scroll indicator UI because the height of the content can be determined without rendering it.
-
-If you have an alternative data type, like an immutable list, `` is the way to go. It takes a `getItem` prop that lets you return the item data for any given index and has looser flow typing.
-
-There are also a bunch of parameters you can tweak if you have an unusual use case. For example, you can use `windowSize` to trade off memory usage vs. user experience, `maxToRenderPerBatch` to adjust fill rate vs. responsiveness, `onEndReachedThreshold` to control when scroll loading happens, and more.
-
-## Future Work ##
-
-* Migration of existing surfaces (ultimately deprecation of `ListView`).
-* More features as we see/hear the need (let us know!).
-* Sticky section header support.
-* More performance optimizations.
-* Support functional item components with state.
diff --git a/blog/2017-03-13-idx-the-existential-function.md b/blog/2017-03-13-idx-the-existential-function.md
deleted file mode 100644
index d10ba1cde0683b..00000000000000
--- a/blog/2017-03-13-idx-the-existential-function.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-title: idx: The Existential Function
-author: Timothy Yung
-authorTitle: Engineering Manager at Facebook
-authorURL: https://github.com/yungsters
-authorImage: https://pbs.twimg.com/profile_images/1592444107/image.jpg
-authorTwitter: yungsters
-category: engineering
----
-
-At Facebook, we often need to access deeply nested values in data structures fetched with GraphQL. On the way to accessing these deeply nested values, it is common for one or more intermediate fields to be nullable. These intermediate fields may be null for a variety of reasons, from failed privacy checks to the mere fact that null happens to be the most flexible way to represent non-fatal errors.
-
-Unfortunately, accessing these deeply nested values is currently tedious and verbose.
-
-```javascript
-props.user &&
-props.user.friends &&
-props.user.friends[0] &&
-props.user.friends[0].friends
-```
-
-There is [an ECMAScript proposal to introduce the existential operator](https://github.com/claudepache/es-optional-chaining) which will make this much more convenient. But until a time when that proposal is finalized, we want a solution that improves our quality of life, maintains existing language semantics, and encourages type safety with Flow.
-
-We came up with an existential _function_ we call `idx`.
-
-```javascript
-idx(props, _ => _.user.friends[0].friends)
-```
-
-The invocation in this code snippet behaves similarly to the boolean expression in the code snippet above, except with significantly less repetition. The `idx` function takes exactly two arguments:
-
-- Any value, typically an object or array into which you want to access a nested value.
-- A function that receives the first argument and accesses a nested value on it.
-
-In theory, the `idx` function will try-catch errors that are the result of accessing properties on null or undefined. If such an error is caught, it will return either null or undefined. (And you can see how this might be implemented in [idx.js](https://github.com/facebookincubator/idx/blob/master/packages/idx/src/idx.js).)
-
-In practice, try-catching every nested property access is slow, and differentiating between specific kinds of TypeErrors is fragile. To deal with these shortcomings, we created a Babel plugin that transforms the above `idx` invocation into the following expression:
-
-```javascript
-props.user == null ? props.user :
-props.user.friends == null ? props.user.friends :
-props.user.friends[0] == null ? props.user.friends[0] :
-props.user.friends[0].friends
-```
-
-Finally, we added a custom Flow type declaration for `idx` that allows the traversal in the second argument to be properly type-checked while permitting nested access on nullable properties.
-
-The function, Babel plugin, and Flow declaration are now [available on GitHub](https://github.com/facebookincubator/idx). They are used by installing the **idx** and **babel-plugin-idx** npm packages, and adding “idx” to the list of plugins in your `.babelrc` file.
diff --git a/blog/2017-03-13-introducing-create-react-native-app.md b/blog/2017-03-13-introducing-create-react-native-app.md
deleted file mode 100644
index 6aa49895ee3c13..00000000000000
--- a/blog/2017-03-13-introducing-create-react-native-app.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: Introducing Create React Native App
-author: Adam Perry
-authorTitle: Software Engineer at Expo
-authorURL: https://github.com/dikaiosune
-authorImage: https://avatars2.githubusercontent.com/u/6812281
-authorTwitter: dika10sune
-category: engineering
-youtubeVideoId: 9baaVjGdBqs
----
-
-Today we’re announcing [Create React Native App](https://github.com/react-community/create-react-native-app): a new tool that makes it significantly easier to get started with a React Native project! It’s heavily inspired by the design of [Create React App](https://github.com/facebookincubator/create-react-app) and is the product of a collaboration between [Facebook](https://code.facebook.com) and [Expo](https://expo.io) (formerly Exponent).
-
-Many developers struggle with installing and configuring React Native’s current native build dependencies, especially for Android. With Create React Native App, there’s no need to use Xcode or Android Studio, and you can develop for your iOS device using Linux or Windows. This is accomplished using the Expo app, which loads and runs CRNA projects written in pure JavaScript without compiling any native code.
-
-Try creating a new project (replace with suitable yarn commands if you have it installed):
-
-```
-$ npm i -g create-react-native-app
-$ create-react-native-app my-project
-$ cd my-project
-$ npm start
-```
-
-This will start the React Native packager and print a QR code. Open it in the [Expo app](https://expo.io) to load your JavaScript. Calls to `console.log` are forwarded to your terminal. You can make use of any standard React Native APIs as well as the [Expo SDK](https://docs.expo.io/versions/latest/sdk/index.html).
-
-## What about native code?
-
-Many React Native projects have Java or Objective-C/Swift dependencies that need to be compiled. The Expo app does include APIs for camera, video, contacts, and more, and bundles popular libraries like [Airbnb’s react-native-maps](https://docs.expo.io/versions/v14.0.0/sdk/map-view.html), or [Facebook authentication](https://docs.expo.io/versions/latest/sdk/facebook.html). However if you need a native code dependency that Expo doesn’t bundle then you’ll probably need to have your own build configuration for it. Just like Create React App, “ejecting” is supported by CRNA.
-
-You can run `npm run eject` to get a project very similar to what `react-native init` would generate. At that point you’ll need Xcode and/or Android Studio just as you would if you started with `react-native init` , adding libraries with `react-native link` will work, and you’ll have full control over the native code compilation process.
-
-## Questions? Feedback?
-
-Create React Native App is now stable enough for general use, which means we’re very eager to hear about your experience using it! You can find me [on Twitter](https://twitter.com/dika10sune) or open an issue on [the GitHub repository](https://github.com/react-community/create-react-native-app). Pull requests are very welcome!
diff --git a/blog/2017-06-21-react-native-monthly-1.md b/blog/2017-06-21-react-native-monthly-1.md
deleted file mode 100644
index afbbb15373017f..00000000000000
--- a/blog/2017-06-21-react-native-monthly-1.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-title: React Native Monthly #1
-author: Tomislav Tenodi
-authorTitle: Product Manager at Shoutem
-authorURL: https://github.com/tenodi
-authorImage: https://pbs.twimg.com/profile_images/877237660225609729/bKFDwfAq.jpg
-authorTwitter: TomislavTenodi
-category: engineering
----
-
-At [Shoutem](https://shoutem.github.io/), we've been fortunate enough to work with React Native from its very beginnings. We decided we wanted to be part of the amazing community from day one. Soon enough, we realized it's almost impossible to keep up with the pace the community was growing and improving. That's why we decided to organize a monthly meeting where all major React Native contributors can briefly present what their efforts and plans are.
-
-## Monthly meetings
-
-We had our first session of the monthly meeting on June 14, 2017. The mission for React Native Monthly is simple and straightforward: **improve the React Native community**. Presenting teams' efforts eases collaboration between teams done offline.
-
-## Teams
-
-On the first meeting, we had 8 teams join us:
-
-- [Airbnb](https://github.com/airbnb)
-- [Callstack](https://github.com/callstack-io)
-- [Expo](https://github.com/expo)
-- [Facebook](https://github.com/facebook)
-- [GeekyAnts](https://github.com/GeekyAnts)
-- [Microsoft](https://github.com/microsoft)
-- [Shoutem](https://github.com/shoutem)
-- [Wix](https://github.com/wix)
-
-We hope to have more core contributors join the upcoming sessions!
-
-## Notes
-
-As teams' plans might be of interest to a broader audience, we'll be sharing them here, on the React Native blog. So, here they are:
-
-### Airbnb
-
-- Plans to add some A11y (accessibility) APIs to `View` and the `AccessibilityInfo` native module.
-- Will be investigating adding some APIs to native modules on Android to allow for specifying threads for them to run on.
-- Have been investigating potential initialization performance improvements.
-- Have been investigating some more sophisticated bundling strategies to use on top of "unbundle".
-
-### Callstack
-
-- Looking into improving the release process by using [Detox](https://github.com/wix/detox) for E2E testing. Pull request should land soon.
-- Blob pull request they have been working on has been merged, subsequent pull requests coming up.
-- Increasing [Haul](https://github.com/callstack-io/haul) adoption across internal projects to see how it performs compared to [Metro](https://github.com/facebook/metro). Working on better multi-threaded performance with the Webpack team.
-- Internally, they have implemented a better infrastructure to manage open source projects. Plans to be getting more stuff out in upcoming weeks.
-- The React Native Europe conference is coming along, nothing interesting yet, but y'all invited!
-- Stepped back from [react-navigation](https://github.com/react-community/react-navigation) for a while to investigate alternatives (especially native navigations).
-
-### Expo
-
-- Working on making it possible to install npm modules in [Snack](https://snack.expo.io/), will be useful for libraries to add examples to documentation.
-- Working with [Krzysztof](https://github.com/kmagiera) and other people at [Software Mansion](https://github.com/softwaremansion) on a JSC update on Android and a gesture handling library.
-- [Adam Miskiewicz](https://github.com/skevy) is transitioning his focus towards [react-navigation](https://github.com/react-community/react-navigation).
-- [Create React Native App](https://github.com/react-community/create-react-native-app) is in the [Getting Started guide](https://facebook.github.io/react-native/docs/getting-started.html) in the docs. Expo wants to encourage library authors to explain clearly whether their lib works with CRNA or not, and if so, explain how to set it up.
-
-### Facebook
-
-- React Native's packager is now [Metro](https://github.com/facebook/metro), in an independent repo. The Metro Bundler team in London is excited to address the needs of the community, improve modularity for additional use-cases beyond React Native, and increase responsiveness on issues and PRs.
-- In the coming months, the React Native team will work on refining the APIs of primitive components. Expect improvements in layout quirks, accessibility, and flow typing.
-- The React Native team also plans on improving core modularity this year, by refactoring to fully support 3rd party platforms such as Windows and macOS.
-
-### GeekyAnts
-
-- The team is working on a UI/UX design app (codename: Builder) which directly works with `.js` files. Right now, it supports only React Native. It’s similar to Adobe XD and Sketch.
-- The team is working hard so that you can load up an existing React Native app in the editor, make changes (visually, as a designer) and save the changes directly to the JS file.
-- Folks are trying to bridge the gap between Designers and Developers and bring them on the same repo.
-- Also, [NativeBase](https://github.com/GeekyAnts/NativeBase) recently reached 5,000 GitHub stars.
-
-### Microsoft
-
-- [CodePush](https://github.com/Microsoft/code-push) has now been integrated into [Mobile Center](https://mobile.azure.com/). This is the first step in providing a much more integrated experience with distribution, analytics and other services. See their announcement [here](https://microsoft.github.io/code-push/articles/CodePushOnMobileCenter.html).
-- [VSCode](https://github.com/Microsoft/vscode) has a bug with debugging, they are working on fixing that right now and will have a new build.
-- Investigating [Detox](https://github.com/wix/detox) for Integration testing, looking at JSC Context to get variables alongside crash reports.
-
-### Shoutem
-
-- Making it easier to work on Shoutem apps with tools from the React Native community. You will be able to use all the React Native commands to run the apps created on [Shoutem](https://shoutem.github.io/).
-- Investigating profiling tools for React Native. They had a lot of problems setting it up and they will write some of the insights they discovered along the way.
-- Shoutem is working on making it easier to integrate React Native with existing native apps. They will document the concept that they developed internally in the company, in order to get the feedback from the community.
-
-### Wix
-
-- Working internally to adopt [Detox](https://github.com/wix/detox) to move significant parts of the Wix app to "zero manual QA". As a result, Detox is being used heavily in a production setting by dozens of developers and maturing rapidly.
-- Working to add support to the [Metro](https://github.com/facebook/metro) for overriding any file extension during the build. Instead of just "ios" and "android", it would support any custom extension like "e2e" or "detox". Plans to use this for E2E mocking. There's already a library out called [react-native-repackager](https://github.com/wix/react-native-repackager), now working on a PR.
-- Investigating automation of performance tests. This is a new repo called [DetoxInstruments](https://github.com/wix/DetoxInstruments). You can take a look, it's being developed open source.
-- Working with a contributor from KPN on Detox for Android and supporting real devices.
-- Thinking about "Detox as a platform" to allow building other tools that need to automate the simulator/device. An example is [Storybook](https://github.com/storybooks/react-native-storybook) for React Native or Ram's idea for integration testing.
-
-## Next session
-
-Meetings will be held every four weeks. The next session is scheduled for July 12, 2017. As we just started with this meeting, we'd like to know how do these notes benefit the React Native community. Feel free to ping me [on Twitter](https://twitter.com/TomislavTenodi) if you have any suggestion on what we should cover in the following sessions, or how we should improve the output of the meeting.
diff --git a/blog/2017-07-28-react-native-monthly-2.md b/blog/2017-07-28-react-native-monthly-2.md
deleted file mode 100644
index c24e12aa738f96..00000000000000
--- a/blog/2017-07-28-react-native-monthly-2.md
+++ /dev/null
@@ -1,100 +0,0 @@
----
-title: React Native Monthly #2
-author: Tomislav Tenodi
-authorTitle: Product Manager at Shoutem
-authorURL: https://github.com/tenodi
-authorImage: https://pbs.twimg.com/profile_images/877237660225609729/bKFDwfAq.jpg
-authorTwitter: TomislavTenodi
-category: engineering
----
-
-The React Native monthly meeting continues! On this session, we were joined by [Infinite Red](https://infinite.red/), great minds behind [Chain React, the React Native Conference](https://infinite.red/ChainReactConf). As most of the people here were presenting talks at Chain React, we pushed the meeting to a week later. Talks from the conference have been [posted online](https://www.youtube.com/playlist?list=PLFHvL21g9bk3RxJ1Ut5nR_uTZFVOxu522) and I encourage you to check them out. So, let's see what our teams are up to.
-
-## Teams
-
-On this second meeting, we had 9 teams join us:
-
-- [Airbnb](https://github.com/airbnb)
-- [Callstack](https://github.com/callstack-io)
-- [Expo](https://github.com/expo)
-- [Facebook](https://github.com/facebook)
-- [GeekyAnts](https://github.com/GeekyAnts)
-- [Infinite Red](https://github.com/infinitered)
-- [Microsoft](https://github.com/microsoft)
-- [Shoutem](https://github.com/shoutem)
-- [Wix](https://github.com/wix)
-
-## Notes
-
-Here are the notes from each team:
-
-### Airbnb
-
-- Check out the [Airbnb repository](https://github.com/airbnb) for React Native related projects.
-
-### Callstack
-
-- [Mike Grabowski](https://github.com/grabbou) has been managing React Native's monthly releases as always, including a few betas that were pushed out. In particular, working on getting a v0.43.5 build published to npm since it unblocks Windows users!
-- Slow but consistent work is happening on [Haul](https://github.com/callstack-io/haul). There is a pull request that adds HMR, and other improvements have shipped. Recently got a few industry leaders to adopt it. Possibly planning to start a full-time paid work in that area.
-- [Michał Pierzchała](https://twitter.com/thymikee) from the [Jest](https://github.com/facebook/jest) team has joined us at Callstack this month. He will help maintain [Haul](https://github.com/callstack-io/haul) and possibly work on [Metro Bundler](https://github.com/facebook/metro) and [Jest](https://github.com/facebook/jest).
-- [Satyajit Sahoo](https://twitter.com/satya164) is now with us, yay!
-- Got a bunch of cool stuff coming up from our OSS department. In particular, working on bringing Material Palette API to React Native. Planning to finally release our native iOS kit which is aimed to provide 1:1 look & feel of native components.
-
-### Expo
-
-- Recently launched [Native Directory](https://native.directory) to help with discoverability and evaluation of libraries in React Native ecosystem. The problem: lots of libraries, hard to test, need to manually apply heuristics and not immediately obvious which ones are just the best ones that you should use. It's also hard to know if something is compatible with CRNA/Expo. So Native Directory tries to solve these problems. Check it out and [add your library](https://github.com/react-community/native-directory) to it. The list of libraries is in [here](https://github.com/react-community/native-directory/blob/master/react-native-libraries.json). This is just our first pass of it, and we want this to be owned and run by the community, not just Expo folks. So please pitch in if you think this is valuable and want to make it better!
-- Added initial support for installing npm packages in [Snack](https://snack.expo.io/) with Expo SDK 19. Let us know if you run into any issues with it, we are still working through some bugs. Along with Native Directory, this should make it easy to test libraries that have only JS dependencies, or dependencies included in [Expo SDK](https://github.com/expo/expo-sdk). Try it out:
- - [react-native-modal](https://snack.expo.io/ByBCD_2r-)
- - [react-native-animatable](https://snack.expo.io/SJfJguhrW)
- - [react-native-calendars](https://snack.expo.io/HkoXUdhr-)
-- [Released Expo SDK19](https://blog.expo.io/expo-sdk-v19-0-0-is-now-available-821a62b58d3d) with a bunch of improvements across the board, and we're now using the [updated Android JSC](https://github.com/SoftwareMansion/jsc-android-buildscripts).
-- Working on a guide in docs with [Alexander Kotliarskyi](https://github.com/frantic) with a list of tips on how to improve the user experience of your app. Please join in and add to the list or help write some of it!
- - Issue: [#14979](https://github.com/facebook/react-native/issues/14979)
- - Initial pull request: [#14993](https://github.com/facebook/react-native/pull/14993)
-- Continuing to work on: audio/video, camera, gestures (with Software Mansion, `react-native-gesture-handler`), GL camera integration and hoping to land some of these for the first time in SDK20 (August), and significant improvements to others by then as well. We're just getting started on building infrastructure into the Expo client for background work (geolocation, audio, handling notifications, etc.).
-- [Adam Miskiewicz](https://twitter.com/skevy) has made some nice progress on imitating the transitions from [UINavigationController](https://developer.apple.com/documentation/uikit/uinavigationcontroller) in [react-navigation](https://github.com/react-community/react-navigation). Check out an earlier version of it in [his tweet](https://twitter.com/skevy/status/884932473070735361) - release coming with it soon. Also check out `MaskedViewIOS` which he [upstreamed](https://github.com/facebook/react-native/commit/8ea6cea39a3db6171dd74838a6eea4631cf42bba). If you have the skills and desire to implement `MaskedView` for Android that would be awesome!
-
-### Facebook
-
-- Facebook is internally exploring being able to embed native [ComponentKit](http://componentkit.org/) and [Litho](https://fblitho.com/) components inside of React Native.
-- Contributions to React Native are very welcome! If you are wondering how you can contribute, the ["How to Contribute" guide](http://facebook.github.io/react-native/docs/contributing.html) describes our development process and lays out the steps to send your first pull request. There are other ways to contribute that do not require writing code, such as by triaging issues or updating the docs.
- - At the time of writing, React Native has **635** [open issues](https://github.com/facebook/react-native/issues) and **249** [open pull requests](https://github.com/facebook/react-native/pulls). This is overwhelming for our maintainers, and when things get fixed internally, it is difficult to ensure the relevant tasks are updated.
- - We are unsure what the best approach is to handle this while keeping the community satisfied. Some (but not all!) options include closing stale issues, giving significantly more people permissions to manage issues, and automatically closing issues that do not follow the issue template. We wrote a ["What to Expect from Maintainers"](https://facebook.github.io/react-native/docs/maintainers.html) guide to set expectations and avoid surprises. If you have ideas on how we can make this experience better for maintainers as well as ensuring people opening issues and pull requests feel heard and valued, please let us know!
-
-### GeekyAnts
-
-- We demoed the Designer Tool which works with React Native files on Chain React. Many attendees signed up for the waiting list.
-- We are also looking at other cross-platform solutions like [Google Flutter](https://flutter.io/) (a major comparison coming along), [Kotlin Native](https://github.com/JetBrains/kotlin-native), and [Apache Weex](https://weex.incubator.apache.org/) to understand the architectural differences and what we can learn from them to improve the overall performance of React Native.
-- Switched to [react-navigation](https://github.com/react-community/react-navigation) for most of our apps, which has improved the overall performance.
-- Also, announced [NativeBase Market](https://market.nativebase.io/) - A marketplace for React Native components and apps (for and by the developers).
-
-### Infinite Red
-
-- We want to introduce the [Reactotron](https://github.com/infinitered/reactotron). Check out the [introductory video](https://www.youtube.com/watch?v=tPBRfxswDjA). We'll be adding more features very soon!
-- Organised Chain React Conference. It was awesome, thanks all for coming! [The videos are now online!](https://www.youtube.com/playlist?list=PLFHvL21g9bk3RxJ1Ut5nR_uTZFVOxu522)
-
-### Microsoft
-
-- [CodePush](https://github.com/Microsoft/code-push) has now been integrated into [Mobile Center](https://mobile.azure.com/). Existing users will have no change in their workflow.
- - Some people have reported an issue with duplicate apps - they already had an app on Mobile Center. We are working on resolving them, but if you have two apps, let us know, and we can merge them for you.
-- Mobile Center now supports Push Notifications for CodePush. We also showed how a combination of Notifications and CodePush could be used for A/B testing apps - something unique to the ReactNative architecture.
-- [VSCode](https://github.com/Microsoft/vscode) has a known debugging issue with ReactNative - the next release of the extension in a couple of days will be fixing the issue.
-- Since there are many other teams also working on React Native inside Microsoft, we will work on getting better representation from all the groups for the next meeting.
-
-### Shoutem
-
-- Finished the process of making the React Native development easier on [Shoutem](https://shoutem.github.io/). You can use all the standard `react-native` commands when developing apps on Shoutem.
-- We did a lot of work trying to figure out how to best approach the profiling on React Native. A big chunk of [documentation](https://facebook.github.io/react-native/docs/performance.html) is outdated, and we'll do our best to create a pull request on the official docs or at least write some of our conclusions in a blog post.
-- Switching our navigation solution to [react-navigation](https://github.com/react-community/react-navigation), so we might have some feedback soon.
-- We released [a new HTML component](https://github.com/shoutem/ui/tree/develop/html) in our toolkit which transforms the raw HTML to the React Native components tree.
-
-### Wix
-
-- We started working on a pull request to [Metro Bundler](https://github.com/facebook/metro) with [react-native-repackager](https://github.com/wix/react-native-repackager) capabilities. We updated react-native-repackager to support RN 44 (which we use in production). We are using it for our mocking infrastructure for [detox](https://github.com/wix/detox).
-- We have been covering the Wix app in detox tests for the last three weeks. It's an amazing learning experience of how to reduce manual QA in an app of this scale (over 40 engineers). We have resolved several issues with detox as a result, a new version was just published. I am happy to report that we are living up to the "zero flakiness policy" and the tests are passing consistently so far.
-- Detox for Android is moving forward nicely. We are getting significant help from the community. We are expecting an initial version in about two weeks.
-- [DetoxInstruments](https://github.com/wix/detoxinstruments), our performance testing tool, is getting a little bigger than we originally intended. We are now planning to turn it into a standalone tool that will not be tightly coupled to detox. It will allow investigating the performance of iOS apps in general. It will also be integrated with detox so we can run automated tests on performance metrics.
-
-## Next session
-
-The next session is scheduled for August 16, 2017. As this was only our second meeting, we'd like to know how do these notes benefit the React Native community. Feel free to ping me [on Twitter](https://twitter.com/TomislavTenodi) if you have any suggestion on how we should improve the output of the meeting.
diff --git a/blog/2017-08-07-react-native-performance-in-marketplace.md b/blog/2017-08-07-react-native-performance-in-marketplace.md
deleted file mode 100644
index 88bcbe19a7b6f3..00000000000000
--- a/blog/2017-08-07-react-native-performance-in-marketplace.md
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: React Native Performance in Marketplace
-author: Aaron Chiu
-authorTitle: Software Engineer at Facebook
-authorURL: https://www.facebook.com/aaronechiu
-authorImage: https://fb-s-d-a.akamaihd.net/h-ak-fbx/v/t1.0-9/185908_1738453495300_6268428_n.jpg?_nc_log=1&oh=b0d497607c0d2012e88fde70cf4c7c7e&oe=59ED387B&__gda__=1509259466_d31a1cfbe282168c51f63019db5db391
-authorTwitter: AaaChiuuu
-category: engineering
----
-
-React Native is used in multiple places across multiple apps in the Facebook family including a top level tab in the main Facebook apps. Our focus for this post is a highly visible product, [Marketplace](https://newsroom.fb.com/news/2016/10/introducing-marketplace-buy-and-sell-with-your-local-community/). It is available in a dozen or so countries and enables users to discover products and services provided by other users.
-
-In the first half of 2017, through the joint effort of the Relay Team, the Marketplace team, the Mobile JS Platform team, and the React Native team, we cut Marketplace Time to Interaction (TTI) in half for Android [Year Class 2010-11 devices](https://code.facebook.com/posts/307478339448736/year-class-a-classification-system-for-android/). Facebook has historically considered these devices as low-end Android devices, and they have the slowest TTIs on any platform or device type.
-
-A typical React Native startup looks something like this:
-
-[](/react-native/blog/img/RNPerformanceStartup.png)
-
-> Disclaimer: ratios aren't representative and will vary depending on how React Native is configured and used.
-
-We first initialize the React Native core (aka the “Bridge”) before running the product specific JavaScript which determines what native views React Native will render in the Native Processing Time.
-
-### A different approach
-
-One of the earlier mistakes that we made was to let [Systrace and CTScan](https://code.facebook.com/posts/747457662026706/performance-instrumentation-for-android-apps/) drive our performance efforts. These tools helped us find a lot of low-hanging fruit in 2016, but we discovered that both Systrace and CTScan are **not representative of production scenarios** and cannot emulate what happens in the wild. Ratios of time spent in the breakdowns are often incorrect and, wildly off-base at times. At the extreme, some things that we expected to take a few milliseconds actually take hundreds or thousands of milliseconds. That said, CTScan is useful and we've found it catches a third of regressions before they hit production.
-
-On Android, we attribute the shortcomings of these tools to the fact that 1) React Native is a multithreaded framework, 2) Marketplace is co-located with a multitude of complex views such as Newsfeed and other top-level tabs, and 3) computation times vary wildly. Thus, this half, we let production measurements and breakdowns drive almost all of our decision making and prioritization.
-
-### Down the path of production instrumentation
-
-Instrumenting production may sound simple on the surface, but it turned out to be quite a complex process. It took multiple iteration cycles of 2-3 weeks each; due to the latency of landing a commit in master, to pushing the app to the Play Store, to gathering sufficient production samples to have confidence in our work. Each iteration cycle involved discovering if our breakdowns were accurate, if they had the right level of granularity, and if they properly added up to the whole time span. We could not rely on alpha and beta releases because they are not representative of the general population. In essence, we very tediously built a very accurate production trace based on the aggregate of millions of samples.
-
-One of the reasons we meticulously verified that every millisecond in breakdowns properly added up to their parent metrics was that we realized early on there were gaps in our instrumentation. It turned out that our initial breakdowns did not account for stalls caused by thread jumps. Thread jumps themselves aren't expensive, but thread jumps to busy threads already doing work are very expensive. We eventually reproduced these blockages locally by sprinkling `Thread.sleep()` calls at the right moments, and we managed to fix them by:
-
-1. removing our dependency on AsyncTask,
-2. undoing the forced initialization of ReactContext and NativeModules on the UI thread, and
-3. removing the dependency on measuring the ReactRootView at initialization time.
-
-Together, removing these thread blockage issues reduced the startup time by over 25%.
-
-Production metrics also challenged some of our prior assumptions. For example, we used to pre-load many JavaScript modules on the startup path under the assumption that co-locating modules in one bundle would reduce their initialization cost. However, the cost of pre-loading and co-locating these modules far outweighed the benefits. By re-configuring our inline require blacklists and removing JavaScript modules from the startup path, we were able to avoid loading unnecessary modules such as Relay Classic (when only [Relay Modern](https://facebook.github.io/relay/docs/new-in-relay-modern.html) was necessary). Today, our `RUN_JS_BUNDLE` breakdown is over 75% faster.
-
-We also found wins by investigating product-specific native modules. For example, by lazily injecting a native module's dependencies, we reduced that native module's cost by 98%. By removing the contention of Marketplace startup with other products, we reduced startup by an equivalent interval.
-
-The best part is that many of these improvements are broadly applicable to all screens built with React Native.
-
-## Conclusion
-
-People assume that React Native startup performance problems are caused by JavaScript being slow or exceedingly high network times. While speeding up things like JavaScript would bring down TTI by a non-trivial sum, each of these contribute a much smaller percentage of TTI than was previously believed.
-
-The lesson so far has been to *measure, measure, measure!* Some wins come from moving run-time costs to build time, such as Relay Modern and [Lazy NativeModules](https://github.com/facebook/react-native/commit/797ca6c219b2a44f88f10c61d91e8cc21e2f306e). Other wins come from avoiding work by being smarter about parallelizing code or removing dead code. And some wins come from large architectural changes to React Native, such as cleaning up thread blockages. There is no grand solution to performance, and longer-term performance wins will come from incremental instrumentation and improvements. Do not let cognitive bias influence your decisions. Instead, carefully gather and interpret production data to guide future work.
-
-## Future plans
-
-In the long term, we want Marketplace TTI to be comparable to similar products built with Native, and, in general, have React Native performance on par with native performance. Further more, although this half we drastically reduced the bridge startup cost by about 80%, we plan to bring the cost of the React Native bridge close to zero via projects like [Prepack](https://prepack.io/) and more build time processing.
-
-
diff --git a/blog/2017-08-30-react-native-monthly-3.md b/blog/2017-08-30-react-native-monthly-3.md
deleted file mode 100644
index c46cdd463c4cdd..00000000000000
--- a/blog/2017-08-30-react-native-monthly-3.md
+++ /dev/null
@@ -1,60 +0,0 @@
----
-title: React Native Monthly #3
-author: Mike Grabowski
-authorTitle: CTO at Callstack
-authorURL: https://github.com/grabbou
-authorImage: https://pbs.twimg.com/profile_images/836150188725121024/NkU0AcqW_400x400.jpg
-authorTwitter: grabbou
-category: engineering
----
-
-The React Native monthly meeting continues! This month's meeting was a bit shorter as most of our teams were busy shipping. Next month, we are at [React Native EU](https://react-native.eu/) conference in Wroclaw, Poland. Make sure to grab a ticket and see you there in person! Meanwhile, let's see what our teams are up to.
-
-## Teams
-
-On this third meeting, we had 5 teams join us:
-
-- [Callstack](https://github.com/callstack-io)
-- [Expo](https://github.com/expo)
-- [Facebook](https://github.com/facebook)
-- [Microsoft](https://github.com/microsoft)
-- [Shoutem](https://github.com/shoutem)
-
-## Notes
-
-Here are the notes from each team:
-
-### Callstack
-
-- Recently open sourced [`react-native-material-palette`](https://github.com/callstack-io/react-native-material-palette). It extracts prominent colors from images to help you create visually engaging apps. It's Android only at the moment, but we are looking into adding support for iOS in the future.
-- We have landed HMR support into [`haul`](https://github.com/callstack-io/haul) and a bunch of other, cool stuff! Check out latest releases.
-- React Native EU 2017 is coming! Next month is all about React Native and Poland! Make sure to grab last tickets available [here](https://react-native.eu/).
-
-### Expo
-
-- Released support for installing npm packages on [Snack](https://snack.expo.io). Usual Expo restrictions apply -- packages can't depend on custom native APIs that aren't already included in Expo. We are also working on supporting multiple files and uploading assets in Snack. [Satyajit](https://github.com/satya164) will talk about Snack at [React Native Europe](https://react-native.eu/).
-- Released SDK20 with camera, payments, secure storage, magnetometer, pause/resume fs downloads, and improved splash/loading screen.
-- Continuing to work with [Krzysztof](https://github.com/kmagiera) on [react-native-gesture-handler](https://github.com/kmagiera/react-native-gesture-handler). Please give it a try, rebuild some gesture that you have previously built using PanResponder or native gesture recognizers and let us know what issues you encounter.
-- Experimenting with JSC debugging protocol, working on a bunch of feature requests on [Canny](https://expo.canny.io/feature-requests).
-
-### Facebook
-
-- Last month we discussed management of the GitHub issue tracker and that we would try to make improvements to address the maintainability of the project.
-- Currently, the number of open issues is holding steady at around 600, and it seems like it may stay that way for a while. In the past month, we have closed 690 issues due to lack of activity (defined as no comments in the last 60 days). Out of those 690 issues, 58 were re-opened for a variety of reasons (a maintainer committed to providing a fix, or a contributor made a great case for keeping the issue open).
-- We plan to continue with the automated closing of stale issues for the foreseeable future. We’d like to be in a state where every impactful issue opened in the tracker is acted upon, but we’re not there yet. We need all the help we can from maintainers to triage issues and make sure we don't miss issues that introduce regressions or introduce breaking changes, especially those that affect newly created projects. People interested in helping out can use the Facebook GitHub Bot to triage issues and pull requests. The new [Maintainers Guide](https://facebook.github.io/react-native/docs/maintainers.html) contains more information on triage and use of the GitHub Bot. Please add yourself to the [issue task force](https://github.com/facebook/react-native/blob/master/bots/IssueCommands.txt) and encourage other active community members to do the same!
-
-### Microsoft
-
-- The new Skype app is built on top of React Native in order to facilitate sharing as much code between platforms as possible. The React Native-based Skype app is currently available in the iOS and Android app stores.
-- While building the Skype app on React Native, we send pull requests to React Native in order to address bugs and missing features that we come across. So far, we've gotten about [70 pull requests merged](https://github.com/facebook/react-native/pulls?utf8=%E2%9C%93&q=is%3Apr%20author%3Arigdern%20).
-- React Native enabled us to power both the iOS and Android Skype apps from the same codebase. We also want to use that codebase to power the Skype web app. To help us achieve that goal, we built and open sourced a thin layer on top of React/React Native called [ReactXP](https://microsoft.github.io/reactxp/blog/2017/04/06/introducing-reactxp.html). ReactXP provides a set of cross platform components that get mapped to React Native when targeting iOS/Android and to react-dom when targeting the web. ReactXP's goals are similar to another open source library called React Native for Web. There's a brief description of how the approaches of these libraries differ in the [ReactXP FAQ](https://microsoft.github.io/reactxp/docs/faq.html).
-
-### Shoutem
-
-- We are continuing our efforts on improving and simplifying the developer experience when building apps using [Shoutem](https://shoutem.github.io/).
-- Started migrating all our apps to react-navigation, but we ended postponing this until a more stable version is released, or one of the native navigation solutions becomes stable.
-- Updating all our [extensions](https://github.com/shoutem/extensions) and most of our open source libraries ([animation](https://github.com/shoutem/animation), [theme](https://github.com/shoutem/theme), [ui](https://github.com/shoutem/ui)) to React Native 0.47.1.
-
-## Next session
-
-The next session is scheduled for Wednesday 13, September 2017. As this was only our third meeting, we'd like to know how do these notes benefit the React Native community. Feel free to ping me [on Twitter](https://twitter.com/grabbou) if you have any suggestion on how we should improve the output of the meeting.
diff --git a/blog/2017-09-21-react-native-monthly-4.md b/blog/2017-09-21-react-native-monthly-4.md
deleted file mode 100644
index f35faaa33c2bc6..00000000000000
--- a/blog/2017-09-21-react-native-monthly-4.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: React Native Monthly #4
-author: Mike Grabowski
-authorTitle: CTO at Callstack
-authorURL: https://github.com/grabbou
-authorImage: https://pbs.twimg.com/profile_images/836150188725121024/NkU0AcqW_400x400.jpg
-authorTwitter: grabbou
-category: engineering
----
-
-The React Native monthly meeting continues! Here are the notes from each team:
-
-### Callstack
-
-- [React Native EU](https://react-native.eu) is over. More than 300 participants from 33 countries have visited Wroclaw. Talks can be found [on Youtube](https://www.youtube.com/channel/UCUNE_g1mQPuyW975WjgjYxA/videos).
-- We are slowly getting back to our open source schedule after the conference. One thing worth mentioning is that we are working on a next release of [react-native-opentok](https://github.com/callstack/react-native-opentok) that fixes most of the existing issues.
-
-### GeekyAnts
-
-Trying to lower the entry barrier for the developers embracing React Native with the following things:
-
-- Announced [BuilderX.io](https://builderx.io/) at [React Native EU](https://react-native.eu). BuilderX is a design tool that directly works with JavaScript files (only React Native is supported at the moment) to generate beautiful, readable, and editable code.
-- Launched [ReactNativeSeed.com](https://reactnativeseed.com/) which provides a set of boilerplates for your next React Native project. It comes with a variety of options that include TypeScript & Flow for data-types, MobX, Redux, and mobx-state-tree for state-management with CRNA and plain React-Native as the stack.
-
-### Expo
-
-- Will release SDK 21 shortly, which adds support for react-native 0.48.3 and a bunch of bugfixes/reliability improvements/new features in the Expo SDK, including video recording, a new splash screen API, support for `react-native-gesture-handler`, and improved error handling.
-- Re: [react-native-gesture-handler](https://github.com/kmagiera/react-native-gesture-handler), [Krzysztof Magiera](https://github.com/kmagiera) of [Software Mansion](https://swmansion.com/) continues pushing this forward and we've been helping him with testing it and funding part of his development time. Having this integrated in Expo in SDK21 will allow people to play with it easily in Snack, so we're excited to see what people come up with.
-- Re: improved error logging / handling - see [this gist of an internal Expo PR](https://gist.github.com/brentvatne/00407710a854627aa021fdf90490b958) for details on logging, (in particular, "Problem 2"), and [this commit](https://github.com/expo/xdl/commit/1d62eca293dfb867fc0afc920c3dad94b7209987) for a change that handles failed attempts to import npm standard library modules. There is plenty of opportunity to improve error messages upstream in React Native in this way and we will work on follow up upstream PRs. It would be great for the community to get involved too.
-- [native.directory](https://native.directory/) continues to grow, you can add your projects from [the Github repo](https://github.com/react-community/native-directory).
-- Visit hackathons around North America, including [PennApps](https://pennapps.com/), [Hack The North](http://hackthenorth.com/), [HackMIT](https://hackmit.org/), and soon [MHacks](https://mhacks.org/).
-
-### Facebook
-
-- Working on improving `` and `` components on Android. (Native auto-growing for ``; deeply nested `` components layout issues; better code structure; performance optimizations).
-- We're still looking for additional contributors who would like to help [triage issues and pull requests](https://facebook.github.io/react-native/docs/maintainers.html#facebook-github-bot).
-
-### Microsoft
-
-- Released Code Signing feature for CodePush. React Native developers are now able to sign their application bundles in CodePush. The announcement can be found [here](https://microsoft.github.io/code-push/articles/CodeSigningAnnouncement.html)
-- Working on completing integration of CodePush to Mobile Center. Considering test/crash integration as well.
-
-## Next session
-
-The next session is scheduled for Wednesday 10, October 2017. As this was only our fourth meeting, we'd like to know how do these notes benefit the React Native community. Feel free to ping me [on Twitter](https://twitter.com/grabbou) if you have any suggestion on how we should improve the output of the meeting.
diff --git a/blog/2017-11-06-react-native-monthly-5.md b/blog/2017-11-06-react-native-monthly-5.md
deleted file mode 100644
index a5e65d05bbd3a9..00000000000000
--- a/blog/2017-11-06-react-native-monthly-5.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-title: React Native Monthly #5
-author: Tomislav Tenodi
-authorTitle: Founder at Speck
-authorURL: https://github.com/tenodi
-authorImage: https://pbs.twimg.com/profile_images/877237660225609729/bKFDwfAq.jpg
-authorTwitter: TomislavTenodi
-category: engineering
----
-
-The React Native monthly meeting continues! Let's see what our teams are up to.
-
-### Callstack
-
-- We’ve been working on React Native CI. Most importantly, we have migrated from Travis to Circle, leaving React Native with a single, unified CI pipeline.
-- We’ve organised [Hacktoberfest - React Native edition](https://blog.callstack.io/announcing-hacktoberfest-7313ea5ccf4f) where, together with attendees, we tried to submit many pull requests to open source projects.
-- We keep working on [Haul](https://github.com/callstack/haul). Last month, we have submitted two new releases, including Webpack 3 support. We plan to add [CRNA](https://github.com/react-community/create-react-native-app) and [Expo](https://github.com/expo/expo) support as well as work on better HMR. Our roadmap is public on the issue tracker. If you would like to suggest improvements or give feedback, let us know!
-
-### Expo
-
-- Released [Expo SDK 22](https://blog.expo.io/expo-sdk-v22-0-0-is-now-available-7745bfe97fc6) (using React Native 0.49) and updated [CRNA](https://github.com/react-community/create-react-native-app) for it.
- - Includes improved splash screen API, basic ARKit support, “DeviceMotion” API, SFAuthenticationSession support on iOS11, and [more](https://blog.expo.io/expo-sdk-v22-0-0-is-now-available-7745bfe97fc6).
-- Your [snacks](https://snack.expo.io) can now have multiple JavaScript files and you can upload images and other assets by just dragging them into the editor.
-- Contribute to [react-navigation](https://github.com/react-community/react-navigation) to add support for iPhone X.
-- Focus our attention on rough edges when building large applications with Expo. For example:
- - First-class support for deploying to multiple environments: staging, production, and arbitrary channels. Channels will support rolling back and setting the active release for a given channel. Let us know if you want to be an early tester, [@expo_io](https://twitter.com/expo_io).
- - We are also working on improving our standalone app building infrastructure and adding support for bundling images and other non-code assets in standalone app builds while keeping the ability to update assets over the air.
-
-### Facebook
-
-- Better RTL support:
- - We’re introducing a number of direction-aware styles.
- - Position:
- - (left|right) → (start|end)
- - Margin:
- - margin(Left|Right) → margin(Start|End)
- - Padding:
- - padding(Left|Right) → padding(Start|End)
- - Border:
- - borderTop(Left|Right)Radius → borderTop(Start|End)Radius
- - borderBottom(Left|Right)Radius → borderBottom(Start|End)Radius
- - border(Left|Right)Width → border(Start|End)Width
- - border(Left|Right)Color → border(Start|End)Color
- - The meaning of “left” and “right” were swapped in RTL for position, margin, padding, and border styles. Within a few months, we’re going to remove this behaviour and make “left” always mean “left,” and “right” always mean “right”. The breaking changes are hidden under a flag. Use `I18nManager.swapLeftAndRightInRTL(false)` in your React Native components to opt into them.
-- Working on [Flow](https://github.com/facebook/flow) typing our internal native modules and using those to generate interfaces in Java and protocols in ObjC that the native implementations must implement. We hope this codegen becomes open source next year, at the earliest.
-
-
-### Infinite Red
-
-- New OSS tool for helping React Native and other projects. More [here](https://shift.infinite.red/solidarity-the-cli-for-developer-sanity-672fa81b98e9).
-- Revamping [Ignite](https://github.com/infinitered/ignite) for a new boilerplate release (Code name: Bowser)
-
-### Shoutem
-
-- Improving the development flow on Shoutem. We want to streamline the process from creating an app to first custom screen and make it really easy, thus lowering the barrier for new React Native developers. Prepared a few workshops to test out new features. We also improved [Shoutem CLI](https://github.com/shoutem/cli) to support new flows.
-- [Shoutem UI](https://github.com/shoutem/ui) received a few component improvements and bugfixes. We also checked compatibility with latest React Native versions.
-- Shoutem platform received a few notable updates, new integrations are available as part of the [open-source extensions project](https://github.com/shoutem/extensions). We are really excited to see active development on Shoutem extensions from other developers. We actively contact and offer advice and guidance about their extensions.
-
-## Next session
-
-The next session is scheduled for Wednesday 6, December 2017. Feel free to ping me [on Twitter](https://twitter.com/TomislavTenodi) if you have any suggestion on how we should improve the output of the meeting.
diff --git a/blog/img/RNPerformanceStartup.png b/blog/img/RNPerformanceStartup.png
deleted file mode 100644
index 7f8381c694f7d1..00000000000000
Binary files a/blog/img/RNPerformanceStartup.png and /dev/null differ
diff --git a/blog/img/animated-diagram.png b/blog/img/animated-diagram.png
deleted file mode 100644
index 26019db8ac8d24..00000000000000
Binary files a/blog/img/animated-diagram.png and /dev/null differ
diff --git a/blog/img/big-hero.jpg b/blog/img/big-hero.jpg
deleted file mode 100644
index 98047927b8122f..00000000000000
Binary files a/blog/img/big-hero.jpg and /dev/null differ
diff --git a/blog/img/blue-hero.jpg b/blog/img/blue-hero.jpg
deleted file mode 100644
index 33a9a7ebc97157..00000000000000
Binary files a/blog/img/blue-hero.jpg and /dev/null differ
diff --git a/blog/img/button-android-ios.png b/blog/img/button-android-ios.png
deleted file mode 100644
index 28f7a70911358b..00000000000000
Binary files a/blog/img/button-android-ios.png and /dev/null differ
diff --git a/blog/img/dark-hero.png b/blog/img/dark-hero.png
deleted file mode 100644
index e54bd6598f74a0..00000000000000
Binary files a/blog/img/dark-hero.png and /dev/null differ
diff --git a/blog/img/git-upgrade-conflict.png b/blog/img/git-upgrade-conflict.png
deleted file mode 100644
index ac8a0447310e9f..00000000000000
Binary files a/blog/img/git-upgrade-conflict.png and /dev/null differ
diff --git a/blog/img/git-upgrade-output.png b/blog/img/git-upgrade-output.png
deleted file mode 100644
index 38b52282455395..00000000000000
Binary files a/blog/img/git-upgrade-output.png and /dev/null differ
diff --git a/blog/img/hmr-architecture.png b/blog/img/hmr-architecture.png
deleted file mode 100644
index 2b19d78c82e6d7..00000000000000
Binary files a/blog/img/hmr-architecture.png and /dev/null differ
diff --git a/blog/img/hmr-diamond.png b/blog/img/hmr-diamond.png
deleted file mode 100644
index bb70c8805dd5d4..00000000000000
Binary files a/blog/img/hmr-diamond.png and /dev/null differ
diff --git a/blog/img/hmr-log.png b/blog/img/hmr-log.png
deleted file mode 100644
index 945f8f7c8155d0..00000000000000
Binary files a/blog/img/hmr-log.png and /dev/null differ
diff --git a/blog/img/hmr-proxy.png b/blog/img/hmr-proxy.png
deleted file mode 100644
index 86b74f858a4efb..00000000000000
Binary files a/blog/img/hmr-proxy.png and /dev/null differ
diff --git a/blog/img/hmr-step.png b/blog/img/hmr-step.png
deleted file mode 100644
index 963b571736a0d0..00000000000000
Binary files a/blog/img/hmr-step.png and /dev/null differ
diff --git a/blog/img/rnmsf-august-2016-airbnb.jpg b/blog/img/rnmsf-august-2016-airbnb.jpg
deleted file mode 100644
index bbbc28957fb33c..00000000000000
Binary files a/blog/img/rnmsf-august-2016-airbnb.jpg and /dev/null differ
diff --git a/blog/img/rnmsf-august-2016-docs.jpg b/blog/img/rnmsf-august-2016-docs.jpg
deleted file mode 100644
index a89b25fc26e2f1..00000000000000
Binary files a/blog/img/rnmsf-august-2016-docs.jpg and /dev/null differ
diff --git a/blog/img/rnmsf-august-2016-hero.jpg b/blog/img/rnmsf-august-2016-hero.jpg
deleted file mode 100644
index bd006c916a652b..00000000000000
Binary files a/blog/img/rnmsf-august-2016-hero.jpg and /dev/null differ
diff --git a/blog/img/rnmsf-august-2016-netflix.jpg b/blog/img/rnmsf-august-2016-netflix.jpg
deleted file mode 100644
index 2ee4f0d8deb36f..00000000000000
Binary files a/blog/img/rnmsf-august-2016-netflix.jpg and /dev/null differ
diff --git a/blog/img/rtl-ama-android-hebrew.png b/blog/img/rtl-ama-android-hebrew.png
deleted file mode 100644
index 3d371c3b41d69d..00000000000000
Binary files a/blog/img/rtl-ama-android-hebrew.png and /dev/null differ
diff --git a/blog/img/rtl-ama-ios-arabic.png b/blog/img/rtl-ama-ios-arabic.png
deleted file mode 100644
index 949f6a555eda25..00000000000000
Binary files a/blog/img/rtl-ama-ios-arabic.png and /dev/null differ
diff --git a/blog/img/rtl-demo-forcertl.png b/blog/img/rtl-demo-forcertl.png
deleted file mode 100644
index fc6c3167f7c443..00000000000000
Binary files a/blog/img/rtl-demo-forcertl.png and /dev/null differ
diff --git a/blog/img/rtl-demo-icon-ltr.png b/blog/img/rtl-demo-icon-ltr.png
deleted file mode 100644
index ed3fe429fc2792..00000000000000
Binary files a/blog/img/rtl-demo-icon-ltr.png and /dev/null differ
diff --git a/blog/img/rtl-demo-icon-rtl.png b/blog/img/rtl-demo-icon-rtl.png
deleted file mode 100644
index 13113b0b72daa3..00000000000000
Binary files a/blog/img/rtl-demo-icon-rtl.png and /dev/null differ
diff --git a/blog/img/rtl-demo-listitem-ltr.png b/blog/img/rtl-demo-listitem-ltr.png
deleted file mode 100644
index 5b1718d7923b9e..00000000000000
Binary files a/blog/img/rtl-demo-listitem-ltr.png and /dev/null differ
diff --git a/blog/img/rtl-demo-listitem-rtl.png b/blog/img/rtl-demo-listitem-rtl.png
deleted file mode 100644
index c36d3548a14f29..00000000000000
Binary files a/blog/img/rtl-demo-listitem-rtl.png and /dev/null differ
diff --git a/blog/img/rtl-demo-swipe-ltr.png b/blog/img/rtl-demo-swipe-ltr.png
deleted file mode 100644
index 00369b7a722e60..00000000000000
Binary files a/blog/img/rtl-demo-swipe-ltr.png and /dev/null differ
diff --git a/blog/img/rtl-demo-swipe-rtl.png b/blog/img/rtl-demo-swipe-rtl.png
deleted file mode 100644
index db1973fc0bd869..00000000000000
Binary files a/blog/img/rtl-demo-swipe-rtl.png and /dev/null differ
diff --git a/blog/img/rtl-rn-core-updates.png b/blog/img/rtl-rn-core-updates.png
deleted file mode 100644
index 0827e73cd87312..00000000000000
Binary files a/blog/img/rtl-rn-core-updates.png and /dev/null differ
diff --git a/blog/img/yarn-rncli.png b/blog/img/yarn-rncli.png
deleted file mode 100644
index 7c935161b20924..00000000000000
Binary files a/blog/img/yarn-rncli.png and /dev/null differ
- 
-
- 
- 
- 
- 
- 
-
-