Mobile@Scale Conference London

Today I attended Facebook’s Mobile@Scale Conference, London 2016. Here is a roundup of the day.

Google on iOS by Michele Aiello

This was a really interesting talk to kick off the conference. The talk explained how Google writes and maintains apps for iOS and Android. For me, the key takeaways were:

  • Google uses small feature teams (1 iOS, 1 Android, 1 backend engineer and 1 product manager)
  • Google has the concept of a release train. They release every 2-6 weeks regardless of what code is included in that release. Google use feature flags to enable them to ship small parts of features; the business can then switch the feature on once all the code has been deployed
  • 80% of users are using auto-update
  • Google use shared libraries, UI and components to give clients a consistent look and feel.
  • Google try to share code across iOS and Android wherever possible; they write their applications in C++ or they use java and transpile to object-c.

For me the big surprise in this talk was that Google fundamentally faces the same problems as all other tech companies, with mobile releases. They are forced to release in-frequently and use feature flags to control when features become live.

When mobile IDEs need scale by James Pearce and Al Sutton

This talk was one of the highlights of the day, it delved into editors and what Facebook use to develop on their very large codebase!

  • Intellij/Android studio is the most popular editor for Android development. Intellij has been around longer than Android itself! So the system requirements are very low. As such, Intellij does not fully utilise our modern, powerful machines. Facebook are doing a lot of work trying to improve this so that Intellij does not lag when working with large projects.
  • Facebook is working on a large package for Atom, called nuclide. This has some awesome features and allows you to write ReactJS code for web, iOS and Android.

I took two things away from this talk. Firstly, it became clear to me that Facebook is really going all in with React. Facebook are trying to turn React into the leading language used for development across iOS, Android and the web. On a more personal note, I learned that I should really re-write my atom plugins in ES6 and Babel rather than coffee script. I hate coffee script.

6 lessions learned scaling mobile on SoundCloud by Jamie McDonald and Matej Balantic

The SoundCloud talk followed on really nicely from the earlier Google talk. Jamie and Matej talked about their iOS and Android apps and how they refactored them. They talked about how they deploy software, how they organise their teams and how they ship features. Here are the highlights:

  • SoundCloud use the same UI and feature set for iOS and Android. That reduces technical overhead and is easier for marketing to handle
  • They have a separate API for mobile and public APIs. This allows them to iterate faster on their mobile platforms and experiment with things like lower bandwidth for emerging markets
  • SoundCloud tackle refactoring by using feature switches. They leave the legacy code in there and develop the new code behind a feature switch. Once the new code is ready they turn the feature switch on and only then do they remove the legacy code.
  • Finally, SoundCloud also have the concept of a release train whereby they do a deploy every 2 weeks, regardless of what has been developed.

For me, the biggest takeaway was that SoundCloud has a separate API for mobile. I always thought that it was a best practice to consume your own API (eat your own dog food). However, they obviously feel that the benefits outweigh the drawbacks.

Backend-driven native UIs by John Sundell

John described Spotify’s framework for making UI changes. The framework allows Spotify to quickly test different UI elements like grid vs list layouts.

Infer: Moving fast with static analysis by Dulma Churchill

Dulma and her team have designed an awesome static analysis tool that can be used for statically typed languages, called Infer. Infer can find memory leaks, resource leaks, security flow bugs and null pointers.

3000 images per second by Henna Kermani

Henna talked about scaling up Twitter’s infrastructure for dealing with images. The main takeaway for me was a cool library called fresco which enables you to display images on clients with slow connections.

React native by Pieter De Baets

Pieter’s talk was about using React Native for iOS and Android applications. Here are some of the highlights:

  • Facebook has more mobile users than desktop users
  • The downside of mobile apps:
    • Proprietary platforms
    • Users don’t always upgrade so they get stuck will old bugs
    • Takes longer to deploy
    • Code cannot be shared across platforms
  • Facebook are using React to write code for native apps
  • React Native apps have great support for parallelism (which is critical for mobile applications as it is super import that the main thread doesn’t get locked up)
  • The aim for React Native is: “Learn once write anywhere”

This was another talk from Facebook that highlighted to me how much Facebook are investing in React. Facebook’s dream is, if you learn React, you can write code for any device.

Don’t forget the web by Jeremy Keith

In the final talk of the day Jeremy urged us not to forget about the web. The web will never catch up with mobile but that is okay, native is like an R&D department for the web. With native you get 100% of the features or you get nothing but with web that is not the case.

That’s all!

Tom and Seb

I had a great day at Mobile@Scale. Here is a picture of Seb and I after consuming too much free food.

Videos should be up soon: