Mobilization is a conference dedicated to mobile technologies. The main scope is development of mobile solutions aimed at smartphones and tablets, with particular interest in Android, iOS and HTML5.
Kotlin has been a revolution in the past two years, especially in the Android world which were using outdated versions of Java.
The language leap is so high, that now we are even allowed to put some Functional Programming in the mix.
This is being done through Arrow project, a FP typed library for Kotlin (and compatible with Java)
But, instead of doing a boring theroretical introduction to FP principles, we will see practical examplen on how we can complement our classic OOP with FP structures and patterns Arrow provides, and how can we apply them to have more concise and robust code.
Gestures and animations are a very extensive subjects where advanced development meets very highUX requirements and these meetings seems to be difficult.
During this talk I wish to show two libraries which solve this problem in React Native. In addition I'd like to raise a subject of gesture handling in 'native' developments and consistence of whole gesture system on mobile platforms. What's more, I'm going to present some related experiments.
In this talk Raul describes the approach they have taken at OneView to improve code quality: CICD, Static code analysis, Unit test, testing Android code efficiently, libraries and architectural approach.
This talk will explore how we can use Swift’s strict typing and generics to create structures that better represent our intentions. I will show how this can decrease the use of internal conventions, which can often lead to misunderstandings and mistakes.
With the premiere of the new Mercedes A-Class and its next-generation MBUX interface, the connected car has been taken to the next level. Learn about connected infotainment systems, how mobile-friendly they are, and about the software that powers them.
I'd like to show what Expo is and how it helps in building cross-platform apps with native feeling.
Is Flutter the next big thing in developing multi platform apps with a single codebase. Google seems to think so. So lets try this out by making a Star wars movies app. And see if we can make that run on both Android and IOS by using the Flutter Framework.
Dependency injection (DI) was introduced as one of the modern best practices at a past WWDC, and is getting popular to make an app maintainable, scalable and testable. To apply DI pattern, a DI container is often used to define a dependency graph to retrieve instances with their dependencies resolved.
In this talk, the original author of Swinject, the most popular DI framework for Swift, will introduce DI pattern for an iOS app. The talk is based on the speaker's experience developing a production app used by tens of millions of users.
The talk covers:
After one year working with Kotlin in 5+ production Apps, it is time to show a TDD-based stack that made my development process more pleasant, and my life happier :-)
We found hybrid applications as an amazing way of prototyping. During the talk I'm going to talk how we leverage possibilities of React Native and Cordova, what's the different between them and how your team could benefit from giving it a try.
This talk will cover:
As a mobile app developer, you probably have noticed Google's active efforts on bringing their machine learning expertise to mobile development. From TensorFlow's earliest mobile app demo to TensorFlow Lite and Android Neural Networks API, we are witnessing how latest research (e.g. MobileNet) drastically reduced machine learning model size and CPU / memory consumption on mobile devices. This year, with the beta release of ML Kit, we now have another powerful toolbox to leverage machine learning in the mobile application development.
This talk features a side project Magritte, an educational application that helps people learn foreign languages. It's sort of like Duolingo but with eyes, the application recognizes daily objects using custom machine learning models embedded on device and speaks the vocabulary out loud with the chosen language. By presenting the Magritte app, the talk will reveal how the models for TensorFlow mobile were initially trained and optimized, how the performance was improved with TensorFlow Lite and MobileNets models, and eventually the ongoing migration towards ML Kit.
One of the easiest ways to simplify your code is to switch to the coordinator pattern. The concept is simple enough: why should one view controller know about, create, configure, and display another, when all you're doing is creating the worst form of coupling?
With coordinators you can split up your app into sensible chunks, where each view controller has no concept of where it exists in your app's flow – or even that the flow exists at all.
Smart lights are fun, but have you ever wondered how it works under the hood, when you say to your Google Home something like: "OK Google, turn on the lights"?
Could we just buy some colored LED bulbs for $10, and create our own home automation system, compatible with the Google Assistant?
That's what we will see today, first doing some slight reverse-engineering to understand how those light bulbs work, and then creating an Android Things and an Actions on Google project to control those.
This talk is a way to discover "Actions on Google", "Google Cloud Functions", "Firebase Cloud Firestore" and "Android Things"
The more lines of code we write the more bugs we welcome. Smart and properly tested algorithms are less likely to be wrong, compared to, well.. human beings. This talk is therefore about what I do to avoid boilerplate code and automate everything that needs to run at least twice with the same settings.
This talk will focus on use cases on Android, but most of it can perfectly be applied on other platforms.
While nearly all apps need to perform computations or I/O asynchronously, often off the UI thread (to avoid UI freezes on blocking calls), the solutions have never been straightforward. You could choose between AsyncTask, threads, executors or third-party java libraries, but couldn't avoid the callback hell. Coroutines which came in Kotlin 1.1 are changing this.
Kotlin coroutines allow to write code that reads like a good recipe, line by line, without jumps, yet, doesn't block the calling thread.
This talk will show how coroutines are relevant in many Android components (ViewModels, Jobs, Services, Activities/Fragments, Views…), for I/O, UI animations, Google Play Services Tasks API usage, and custom async logic.
But that's not all. I'll show you how you can take down any callback hell and do things you'd not have done before because it would have polluted your code base too much. You'll also see how Kotlin coroutines can help you handle errors more easily, and exhaustively.
Bluetooth Low Energy, a great callback hell example, can also get good with coroutines, and I'll show how I Made GATT Great Again! If you have some safe BLE devices we can connect to, please, bring them at the conference!
Camera2 has another big callback hell, plus a complex state machine, and I'll also show how to remove it with coroutines and other Kotlin language features!
What you'll learn here will enable you to better take advantage of coroutines features to solve complex problems and deal with hard or badly designed APIs you can't escape.
Today, almost every Android app communicates with a remote server through a provided API. We often forget that mobile applications can work offline. Moreover, network can be down or not connected to the Internet. We may also want to synchronize our data through the WiFi, but not through the mobile data transfer to save user's money. What to do, when connection is lost and someone is using an application at the same time? How can we keep the track of network or Internet connectivity changes in our app? How to deal with this problem across all recent Android versions? How to write an application, which is network aware and optimized to reduce power consumption? If you want to know answers to these questions and get rid of endlessly rolling spinners in your app, then this talk is for you.
Kotlin is an official language for Android development, but did you know you can use the Kotlin language to compile for iOS via LLVM as well as for the web via JS ?
In this talk, I will show how to create a mobile application that runs on Android, on iOS and on the web while remaining true to each platform.
We will see how to organize your code to share your business logic between platforms while keeping the presentation specific to each of them.
Finally, we will discuss the current state of Kotlin multi-platform, as well as its future.
Some might have heard about code quality tools such as Checkstyle, PMD, Findbugs, Lint, Detekt and others but which ones are applicable to Kotlin?
I'll list a bunch of tools, explain what they can do, touch on how they work and most importantly show you how you can start using them to be more productive and save a lot of time.
With the help of these analyzers you can focus on coding conventions in your team, catch a few bugs and concentrate on what really matters when reviewing code.
At Google IO 2018 the Android team announced Jetpack for Android, which is an opinionated set of libraries and architecture, which is a recommendation for Android developers. We at LAB1886, the incubator for the Daimler AG (Mercedes Benz), thought to give it a try with our latest project called RaceScout from AMG. We have the luxury to work always on green fields for projects. So we wanted to share our experience with Jetpack and also give some recommendations for all the library & SDK developers.
The ML Kit for Firebase lets you bring powerful machine learning features to your app whether it's for Android or iOS, and whether you're an experienced machine learning developer or you're just getting started. During this talk we are going to see use cases and best practices to boost your app using this feature.
Architecture keeps being a buzzword in the Android world, even though years have passed since we've seen the first version of the OS. Problems like orientation changes, navigation, data mapping, parsing or display are still around us, and we struggle to make them go away.
Using Kotlin and it's Coroutines, enveloping the application in Rx and finalizing it with Architecture Components, we can bring the end to nuisances that these problems cause. By heavily relying on generics, asynchronous programming and data persistance, we're able to make a solution, that fits most applications and has an understandable API.
We all know that autolayout comes with a performance hit, but how does it really compare to manual layout, especially with the improvements to the autolayout engine in iOS 12? And what’s a performant way to round the corners of an image? CoreText, UILabel, UITextView: how do all the different ways to draw text perform against each other? Let's discuss the performance differences between comparable iOS elements and technologies.
When having to share code between iOS and Android, most companies choose C++. It is a well known language with very good tooling, but it also has a lot of pitfalls. For one, it is a very complex language. It also makes it really easy to accidentally introduce memory leaks or segmentation faults; especially if you're used to automatic memory management via a GC (Kotlin) or Arc (Swift). It also looks quite different from modern language like Swift or Kotlin. Now that we iOS developers got (mostly) rid of Objective-C, and Android Developers got (mostly) rid of Java, it feels archaic having to go back to a language with an archaic Syntax like C++.
Rust looks and feels a lot like Kotlin or Swift, and it offers the same easy ways of sharing code as C++. In addition to that, Rust has a very safe memory management model, high performance, a way to do fearless concurrency, and a very rich package ecosystem. As a bonus, it compiles to WebAssembly, so the shared code could also be used in any HTML5 app. At XING, we started some experiments in Rust in order to find out whether it would be useful to leverage it for code sharing. We're not using it in production yet or anything, but I feel like it would still be nice to introduce it to more developers so they can also start doing some experiments.
In 2016, the Kotlin language has shaken the Android development landscape. It's now time to break the chains from the Java language and get the best of Kotlin.
Koin is a pragmatic dependency injection framework for Kotlin/Android developers. Let's see how it's very simple to take in hand and how it will make your life easier: from basic dependency injection to the Android architecture's components, without forgetting the testing part.
Modular Architecture - insights from a big French e-commerce. How to challenge the status quo, boost team motivation, productivity and start writing cleaner code with more tests? A journey of sailing from monolithic codebase to modules.
Come and hear our story of challenging the status quo and introducing modular architecture:
Have you ever seen a code comment saying "this should never happen"? Have you ever wondered what would happen if it did? Swift has a diverse set of error-handling capabilities, from using throw to send errors up the stack to using a Result to handle errors in asynchronous methods. In this talk, we'll look at the landscape of handling errors in Swift, create new ways of expressing and handling them, and show how even the most impossible code-level situations can have 100% test coverage. By the end, you'll be taking control of the errors in your code, instead of letting them take control of you.
Property delegation is pretty new feature in the programming world and most developers use only small amount of possibilities it provides. On the other hand, class delegation is known for decades and it was promoted by big authorities. All it needed was language support, which was introduced in Kotlin. On this session, we are going to dive into possibilities that Kotlin delegation gives. Let's discover this features and understand its superpowers.
Debugging is an essential, but complex part of app development. No wonder iOS developers have come up with tools that make this process less daunting. By applying a few tricks from our talk, you will be able to speed up debugging on all layers, from networking to the UI. This in turn will reduce the time you need to ship your product.
TomTom builds technology for a moving world. We help drivers – human or computer – to safely drive the 1.2 billion cars in the world. Every day, moving goods or people from A to B. TomTom started 1984 with mapping the world for navigation applications that help drivers finding their way from A to B and so we eliminated the need for paper maps. Later, in 2006, we developed global traffic services and connected navigation applications for drivers to outsmart traffic congestion altogether. Currently, we help drivers navigating their electric vehicles, making sure they do not run out of battery and so we fight range anxiety. Going forward, we already enabling automated vehicles to see beyond its physical sensors by remapping the world in centimeter accuracy and building applications that assist people’s drive or even drive a car all on their own – more safely and more efficient as human drivers.
Tutorials all over the internet explain how to setup tests and write simpler ones, but what about in a real app where things aren't so straightforward?
Everyone agrees, that testing our code is essential for development. Yet, creating clean and readable tests is not a piece of cake.
We put a lot of effort in keeping our codebase in a good shape. But let's be honest - most of testing frameworks aren't modern, friendly tools. That's where Kotlin and it’s ecosystem comes to help. Data and behavior driven testing combined with specifications can give you more freedom - I will show how to apply those strategies to everyday development.
Besides of general ideas, I will discuss Kotlin and Android testing frameworks. You will also learn how we managed to tailor testing patterns for specific problems.
I hope that after my talk you will have bunch of ideas to be more productive while writing tests.
Reliable internet connection can't be taken for granted on mobile devices. Therefore, when network is unavailable, mobile apps should either fail gracefully or be able to work offline.
However, offline work is one of the most challenging topics in mobile development. And it's not just about mobile: the entire system might need to be offline capable.
In this session we will discuss the fundamental challenges of offline work and understand what it takes to implement an offline capable apps.
You developed a feature, tested it yourself - everything works well. You send it to the internal testing, your managers... And they say it is slow!
Artur ran into the exact same situation and dug into the tools that may be used to make your Android app work on 60 frames per second. This presentation is intended for the people who haven't dived into the UI performance yet. You will see some examples of easy and fast ways to check if your app works well and if it is not, how to find the potential problem.
In the presentation, Artur will tell you about:
Flutter is an open-source mobile application development SDK created by Google. It is used to develop applications for Android and iOS by coding just once in Dart and deploying to both of these platforms. Flutter makes it so easy to build mobile apps without impacting the app’s performance. The app it produces is a treat for the eyes as everything is drawn right on the screen, pixel perfect!
“Why do I need this when I already have React Native?”. I got that covered in this talk for you along with the following takeaways:
Why coding twice is not productive anymore?
A brief about how Flutter came into existence
Flutter’s ability to keep the same performance as the native app
Comparison with React Native and other dual platform frameworks
Best resources to get started with Flutter
Fun Fact: Flutter was meant to use JS at first, but the team eventually decided to go with Dart. I’ll talk about this as well.
By the end of this talk, you will be itching to write your first app in Flutter!
Get ready for some engaging questions and punny one-liners ready that would make you want to not miss a second of this talk.
Based on my CryptoSwift open source project experience, I'd like to outline the most frequent issues reported to the support. Programmers comes from various programming environments and uses various schemes, not always understanding what and why. Let's review the most common scenarios to approach encryption with Swift (but in general really)
This talk will learn you how to develop clean, maintainable and stable applications in Swift. It will also look at some examples of how I applied these methods in my work.
The goal of this presentation is to introduce to you the current biometric techniques and review those of them, which are applicable or are already present in the mobile world. We will look under the hood of the most popular use cases and discuss the challenges and the obstacles, which lies ahead of them, both from users and engineer’s perspective.
We will try to prove, that whenever you hear phrase "Enter your PIN code", you have full right to feel like someone who is living in middle age instead of 21st century.
All above just to answer simple question: Is mobile device ready to be our passport to the 7th continent?
Same as previous years, Mobilization 8 is happening at the Lodz International Fairs, the largest organiser of trade shows, exhibitions, domestic and international conferences operating in central Poland.
al. Politechniki 4, 93-590 Łódź, Poland
+48 517 725 068