Speakers

Improve Your App Ratings Using Machine Learning

Why is this relevant for you?
Store ratings are arguably the most crucial marketing tools developers and businesses have to promote their app: They can drive millions of downloads when positive, but also can totally kill the project when negative.
The problem is that it’s very difficult to understand who you should ask for a rating, and when: the wrong user, or the wrong moment, can destroy your chances of getting a 5-stars review. In this workshop, I will show how you can implement a Machine Learning system that will automatically determine both the criteria. What are you going to learn?
I will use Firebase as a middle layer between the clients and the backend, mainly because the overhead required to set it up is almost nil and it poses no limitation for scaling. The Machine Learning algorithm will be coded in Python, and I will be as much specific as possible explaining its underlying functioning: If the system is not a black box to you, you can improve it and customize it based on your needs.
At the end of the workshop, you will be able to implement a system like this on your own app. You will understand how Firebase works, and why it’s the right tool for the job. You will also have a sense of how these problems can be tackled using Machine Learning, and what is the best strategy to do that.

No one at Google uses MapReduce anymore: Cloud Dataflow explained

The MapReduce paper, published by Google more than 10 years ago (2004!), sparked the parallel processing revolution and gave birth to countless open source and research projects.
The MapReduce model is now officially obsolete, so the new data processing model we use is the “Dataflow model” and you can see it in action in the hosted Cloud Dataflow service, or its open source Apache Beam implementation.
They allow you to specify both batch and real-time data processing pipelines and have them deployed and maintained automatically – and yes, dataflow can deploy *lots* of machines to handle Google-scale problems.

Tensorflow and deep learning - without a PhD

Google has recently open-sourced its framework for machine learning and neural networks called Tensorflow.
With this new tool, deep machine learning transitions from an area of research into mainstream software engineering. In this session, we will teach you how to choose the right neural network for your problem and how to make it behave.
Familiarity with differential equations is no longer required.
Instead, a couple of lines of Tensorflow Python, and a bag of "tricks of the trade" will do the job.

No previous Python knowledge required.

Building apps in Go for Google App Engine

Google App Engine provides developers with a NoOps solution for hosting their applications and services. With a configuration file and a few tweaks to the code, a Go package can be deployed to Google’s servers where it’s ready for near infinite scale.

This workshop will explain everything you need to know to get started, along with some pragmatic advice, and common gotchas to avoid.
The workshop covers how to store and query data using Google Cloud Datastore, memcache, options for authenticating users, scheduling background tasks, building micro-services, and more.

QUIT Building apps in Go for Google App Engine

Google App Engine provides developers with a NoOps solution for hosting their applications and services.
With a configuration file and a few tweaks to the code, a Go package can be deployed to Google’s servers where it’s ready for near infinite scale.
This talk will explain everything you need to know to get started, along with some pragmatic advice, and common gotchas to avoid.
The talk covers how to store and query data using Google Cloud Datastore, memcache, options for authenticating users, scheduling background tasks, building micro-services, and more.

Writing Beautiful Packages in Go

Packages are the building blocks of large projects in Go.
Whether intended for internal use, or destined for open-source stardom, writing good packages with clean and clear APIs will greatly increase the chance that the code is used and reused.
This talk will explore best practices, goals, and helpful tips and tricks that help you to write beautiful packages.

What we learnt from Service Workers

Have you heard about Service Workers and thought “They are cool but I probably won’t be able to use them until 2020 anyway”?
Here’s your chance to get a hands-on experience with them in a coding dojo. This way you can make an offline-first web app and see how you can use SW in your production apps.
Coding dojo is way of learning new tech using mob-programming, TDD, and consumer first approach.

You don’t need to have any previous experience, just know a bit of javascript - the other attendees and I will help you with the rest!

Workshop on Kubernetes

The workshop gives a short introduction into Kubernetes. How to create basic pods, replication controllers, services etc.
It is shown how to deploy microservices in an easy and reproducible way through the cli or the web ui.
The workshop is hands-on and can cover only the basics.

One year of shaping applications for Containers, Kubernetes, CoreOS and Co

Following a very strict approach, separating persistent and stateless applications, running everything in small units orchestrated by Kubernetes we could create descriptions of environments very rapidly, deploying complex environments with a single command. Examples in Java, Python and Ruby could be shown. Security has been addressed to pass an extensive security audit.
The talk touches also operational challenges as implementing a deployment pipeline, logging under load, monitoring, distribution of passwords and configurations as limits to the containers resource management.

I just hacked your app!

Android security is nowhere near where it should be. I have been able to hack and get sensitive information from a few different apps and I’m just an amateur hacker at best.
Whether it’s because we are exposing information when making HTTP requests to our backend servers or because we’re simply storing things we shouldn't in our apps, it’s easy to forget mobile devices aren't as safe as we think they are.
In this session we will explore a number of ways an Android app can be exploited and most importantly methods that we can use to avoid these attacks.
We will finish by looking at common techniques that will help you protect sensitive information within your application by adding tampering detection and making sure every external communication request is made securely.

From mono to clean

Good architecture is crucial for any software and Android apps are not different.
A lot has been said about clean architectures but very few people explained how to evolve into them from a typical monolithic approach.
In this talk, I will guide you through my journey on how I evolved from no architecture at all, with business logic and HTTP requests in the activities, into the clean architecture with RxJava based on Fernando Cejas approach.
I will describe the architectural solutions from 4 different apps and the pros and cons of each solution.

? Perception Of Speed

What’s our main complaint when we use an application?

- Speed!

We all expect speed. We want to access everything from the point of our fingers and we want that as fast as possible. When an application is taking to long to open or process some data I bet you also feel the urge to search for another solution - or just to throw your smart phone against the nearest wall in despair. And while you think about this, you’re looking at that never ending spinner… that… it just doesn't seem to go away.
Google Play and the App Store are full of similar solutions… Why should I bother to keep using this one?
We can make all sort of optimisations on our code - and yet, sometimes, we can’t really make that process as fast as we wanted. There are always some constraints that we can’t really avoid - device limitations, network, server, etc. but we can create the illusion of speed - a visual aid that keeps the user busy while, on the background, we are processing his action.
Yes. Time is relative and we want the users to feel that every action is as responsible as possible.

Taking care of your Android UI tests

Most Android UI testing talks focus on how Espresso works and how to start writing simple tests.
This is fine for a simple app but maintaining and expanding those tests gets harder as the app grows. This talk will focus on writing complex tests scenarios while making sure we keep them maintainable, expandable and readable.

I’ll use a released app we developed as an example. This will involve multi-screen scenarios, handling asynchronous operations, providing a fake environment as well as some common and less common Espresso gotchas.

Launch smarter on Google Play

Google Play helps developers build great apps and games, and grow a large user base.
Set your app up for success using iteration and experimentation, and responding to user feedback.
Adapt your app to different markets through experiments.
Learn about increasing your app rating, gaining insights from user reviews, and testing your app easily across multiple devices.

App engagement is the new black

As the app marketplace constantly becomes more competitive, developer success increasingly depends on retaining users in apps they love.
Find out which tactics and tools can help you analyse improve user engagement and retention in your app.

The Next Step for Reactive Android Programming

The way we develop Android applications has dramatically changed in the last few years. One of the biggest aspects of this change is the adoption of the reactive approach to programming. Once a prominent part of the Android landscape, we now almost exclusively see Threads and AsyncTasks in legacy code. Reactive approaches like EventBus, Agera and in particular, RxJava, have taken their place and have reshaped the way we write code.
But they are also evolving: RxJava 2 is on our doorstep.
I will talk about my experience of migrating a highly reactive application, used by millions of users, from RxJava 1.x to 2.x.
Firstly, I will share the advantages and disadvantages of moving to this new milestone release, so you can decide if it’s worth to migrate your application.
I will then focus on possible migration approaches; which strategies worked for me and which did not.
Finally, we can discuss the frustrations that you need to prepare yourself for and how you can avoid them.

Open-source licenses and distribution

Intro to open source licenses
Modern software are built from open source projects. All Android apps use open-source code. As developer, open source save time to focus on the core of your apps. As author of an open source project, licences give control over your work. We are developers not lawyers, but let’s review the major licenses.
Generate open source licenses page
Most of the open source licenses oblige to credit the author of the project. A full “licenses” page in a commercial app will prevent getting into legal troubles. In all successful commercial apps, you will find this page if you know where to look. I authored an elegant library to credit the open source projects used in a commercial Android app. The licenses page of other apps will also be reviewed. Some advanced topics of RecyclerView will be discussed in order to show this project was done. Then I will demo my project http://bit.ly/2d10Wm1 and talk about my plans on how to automate the code generation.
Some tips on open sourcing
Most of us, know how to write apps, I will also share what I learned on publishing a library ( export on Bintray jcenter, travis CI, Github's README)

AMP tries to fix the web. What can we learn from it?

QUIT Scaling Massive, Real-Time Data Pipelines with Go

Passing 10,000 messages a second between apps and data stores is tough. Add on filtering and parsing and you’re bound to run into problems.
At Pivotal Cloud Foundry, we have to handle several factors of that load each day, which means our programs need to be highly concurrent and very careful with state.
Let’s look at some patterns and best practices that can be taken advantage of in order to handle this load.

Kubernetes and Prometheus — cloud natives united

The container orchestration system Kubernetes and the monitoring and alerting systemPrometheus were created independently but share spiritual ancestry far beyond the simple fact that they are both implemented in Go. The twins, separated at birth, are now finally reunified in theCloud Native Computing Foundation (CNCF), which has accepted Prometheus as their second hosted project after Kubernetes. Each project alone is of great importance for “born in the cloud” applications. However, it gets really interesting when you combine the two.

The speaker had an important role in the upbringing of Prometheus at SoundCloud. With more than seven years at Google under his belt, he is also quite familiar with the technologies that served as an inspiration for both, Kubernetes and Prometheus. He will tell you how their beautiful friendship could happen despite their independent development, and he will give you the top five reasons why the two play so nicely together.

Behaviour driven OOP using Traits

We all build software, and we see ourselves using OOP in some manner or the other. Inheritance is one of the core properties of OOP. What are the common variants of Inheritance? Single, multiple, and mixin based inheritance.
All of these suffer from conceptual and practical limitations. Ir-respective of the choice of language, our design ends up the same way. Usually a mesh of interconnected types.
As the size of the project goes and we introduce more types, the complexity and cost of testing that system keeps increasing. The Internet is full of memes on that. We go about identifying and illustrating these problems.
We then talk about traits. A trait is essentially a group of pure methods that compose classes and is a primitive unit of code reuse. In this model, classes are composed from a set of traits by specifying glue code that connects the traits together and accesses the necessary state. We demonstrate how traits overcome these problems, and help you build simpler and reusable code.
This talk is based on a research paper published in “Traits: Composable Units of Behaviour”.
The talk covers code samples of such trait based implementations in Ruby, Python and Golang.

Design patterns in Microservices architectures using Gilmour

Microservices have rapidly evolved over the years as a popular way of developing applications, but they bring their own set of challenges in the form of what design pattern to use, monitoring,logging, error detection, scaling and service discovery.
We will explore the common characteristics and design patterns to be considered while dealing with service oriented architectures. We talk about Signal-Slots, RPC architectures, monitoring, log and error handling, function point scaling, and common unix philosophies that help you design scalable distributes systems.
Diving into code samples, demos and production deployments; I would like to showcase Gilmour (http://github.com/gilmour-libs): a cross language library we have authored for effective micro services that exchange data over non-HTTP transports.

Whats New with Firebase

After this years Google I/O, Firebase was upgraded and become an even more important role in the range of Google services available. Now properly integrated with Google Services, Firebase offers developers much more than than just a database for “personal” projects. The new updated Firebase however has left many developers a bit puzzled on how to properly include Firebase in their projects, how it integrates into Google Services, and how they can make use of the new features available. If you’ve used Firebase already, you might be aware of how to integrate and make use of it in your applications but if not prior knowledge isn’t necessary. In this talk I’d like to share with you how migrate your existing code to the updated versions, what new features you’ll be able to take advantage of, and any pitfalls that you can hopefully avoid!

Modular Android UI

Modular Android UI Discussing how to build complex UIs on Android is a very wide topic. I will try to cover some of the things you can do to make your life easier. This talk is divided into 3 segments: Architecture (options, design patterns) Organizing Android components Making UI modular Organizing things like this helps a lot with scaling the app from a few simple fragments to tens of different, module- or feature-limited, standalone app screens. Architecture This part of the talk covers some basic design patterns you can use to build your app, introduction to my favorite - Model:View:Presenter (MVP), and differences between the Passive View and the Supervising Controller variants of MVP. I will include some tips as well on how to map UI states to data states and reuse the code across the app. Android components The Android framework (including the UI toolkit) already provides basic data structures, UI elements and life-cycle events. As you are organizing and structuring other parts of your app, you will likely want to get the UI to work for you, not the other way around. This part of the talk covers some ideas on how to organize code and make your life easier. Modular UI Finally, the last step. When you have your structure set up and your data structures ready, it’s time to glue it all together - but! You must keep in mind that your app is scaling and becoming bigger, so you want to make it modular. This part covers some of the techniques I came up with over the years, helping me to properly disable/enable UI features, hide/show elements and even re-work the whole screens or even navigation models depending on external factors.

Modular Android UI

Modular Android UI Discussing how to build complex UIs on Android is a very wide topic. I will try to cover some of the things you can do to make your life easier. This talk is divided into 3 segments: Architecture (options, design patterns) Organizing Android components Making UI modular Organizing things like this helps a lot with scaling the app from a few simple fragments to tens of different, module- or feature-limited, standalone app screens. Architecture This part of the talk covers some basic design patterns you can use to build your app, introduction to my favorite - Model:View:Presenter (MVP), and differences between the Passive View and the Supervising Controller variants of MVP. I will include some tips as well on how to map UI states to data states and reuse the code across the app. Android components The Android framework (including the UI toolkit) already provides basic data structures, UI elements and life-cycle events. As you are organizing and structuring other parts of your app, you will likely want to get the UI to work for you, not the other way around. This part of the talk covers some ideas on how to organize code and make your life easier. Modular UI Finally, the last step. When you have your structure set up and your data structures ready, it’s time to glue it all together - but! You must keep in mind that your app is scaling and becoming bigger, so you want to make it modular. This part covers some of the techniques I came up with over the years, helping me to properly disable/enable UI features, hide/show elements and even re-work the whole screens or even navigation models depending on external factors.

Lightning talks

Optimising The Performance Of VectorDrawables

Support for SVG finally arrived to Android in the form of vector drawables. You have replaced (or you are planning to replace) absolutely all your PNGs with VectorDrawables and your APK is smaller. But now your app feels slower, the render time of your views has increased and you don’t know why! In this talk you will learn what VectorDrawables are and how they work under the hood.
I will show you why this is, what effect can big resources have on your app’s performance but also, what are the possible solutions for this. Have you ever tried referencing resources in your VectorDrawable’s XML and failed? The talk will explain why and how to solve this.

REST APIs with a contract-first approach

Most of Android apps are talking to a some kind of REST API services. Libraries like Retrofit make it quite easy to implement decent code talking to a API. Another libraries like Butterknife, @AutoValue or POJO generators are saving us from a writing of boilerplate code.
Lets make a next step and combine these together with a contract-first approach. In this talk we will have a look what contract-first approach is, on possibilities how to define API interfaces, endpoints, data structures (contract), how to generate code and we will share experiences from a real life project.

Exploring the new Google Cloud Endpoints

The Google Cloud Platform team recently announced the release of a new version of Google Cloud Endpoints, a set of tools for implementing and managing APIs based on Google’s own internal experiences and best practices.
This new release not only keeps building on the most successful and useful features from the previous version but also offers more flexibility of deployment, interoperability with industry standards among other benefits.
During this talk you’ll see the main changes and hopefully it’ll get you excited to use them in your next project.

Lightning talks

Optimising The Performance Of VectorDrawables

Support for SVG finally arrived to Android in the form of vector drawables. You have replaced (or you are planning to replace) absolutely all your PNGs with VectorDrawables and your APK is smaller. But now your app feels slower, the render time of your views has increased and you don’t know why! In this talk you will learn what VectorDrawables are and how they work under the hood.
I will show you why this is, what effect can big resources have on your app’s performance but also, what are the possible solutions for this. Have you ever tried referencing resources in your VectorDrawable’s XML and failed? The talk will explain why and how to solve this.

REST APIs with a contract-first approach

Most of Android apps are talking to a some kind of REST API services. Libraries like Retrofit make it quite easy to implement decent code talking to a API. Another libraries like Butterknife, @AutoValue or POJO generators are saving us from a writing of boilerplate code.
Lets make a next step and combine these together with a contract-first approach. In this talk we will have a look what contract-first approach is, on possibilities how to define API interfaces, endpoints, data structures (contract), how to generate code and we will share experiences from a real life project.

Exploring the new Google Cloud Endpoints

The Google Cloud Platform team recently announced the release of a new version of Google Cloud Endpoints, a set of tools for implementing and managing APIs based on Google’s own internal experiences and best practices.
This new release not only keeps building on the most successful and useful features from the previous version but also offers more flexibility of deployment, interoperability with industry standards among other benefits.
During this talk you’ll see the main changes and hopefully it’ll get you excited to use them in your next project.

Lightning talks

Optimising The Performance Of VectorDrawables

Support for SVG finally arrived to Android in the form of vector drawables. You have replaced (or you are planning to replace) absolutely all your PNGs with VectorDrawables and your APK is smaller. But now your app feels slower, the render time of your views has increased and you don’t know why! In this talk you will learn what VectorDrawables are and how they work under the hood.
I will show you why this is, what effect can big resources have on your app’s performance but also, what are the possible solutions for this. Have you ever tried referencing resources in your VectorDrawable’s XML and failed? The talk will explain why and how to solve this.

REST APIs with a contract-first approach

Most of Android apps are talking to a some kind of REST API services. Libraries like Retrofit make it quite easy to implement decent code talking to a API. Another libraries like Butterknife, @AutoValue or POJO generators are saving us from a writing of boilerplate code.
Lets make a next step and combine these together with a contract-first approach. In this talk we will have a look what contract-first approach is, on possibilities how to define API interfaces, endpoints, data structures (contract), how to generate code and we will share experiences from a real life project.

Exploring the new Google Cloud Endpoints

The Google Cloud Platform team recently announced the release of a new version of Google Cloud Endpoints, a set of tools for implementing and managing APIs based on Google’s own internal experiences and best practices.
This new release not only keeps building on the most successful and useful features from the previous version but also offers more flexibility of deployment, interoperability with industry standards among other benefits.
During this talk you’ll see the main changes and hopefully it’ll get you excited to use them in your next project.

Puppy or muffin? Easily leverage machine learning in your apps

Want to take advantage of machine learning without building and training your own models? The Google Cloud Vision and Speech APIs expose the machine learning functionality behind Google Photos, Google Images, and the speech recognition in “Ok, Google.” Developers can now build these features into their apps with a simple REST API call. We’ll provide an overview of these APIs, dive into code, and risk it all with a live demo.

Daydreaming about Cardboards: Virtual Reality in Android

On this year's IO Google announced Daydream, a new way of integrating your apps with Virtual Reality.

To prepare the audience for those new changes, I'll explain the current situation of the VR on Android by live coding two apps: An app using Unity to produce an App on Android and Ios, but also show how to write a simple photosphere app, written in pure Java, emphasizing the differences and similarities between both SDKs.

After showing how to easily write Cardboard Apps, I'll introduce Daydream, and how this specification changes the usage of the SDK and how to use the simulated, or real controller.

Firebase Codelab

In this workshop we will do a small intro to firebase on Android and after that we will go through the Firebase Android Codelab in a self spaced manner.

If you join this session please have Android Studio already installed.