About

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 and iOS.

Sponsors

Partners

Speakers

Mobilizing the World

Talks

2+ years of Flutter - Retrospection

Michał
Baran

Rafal
Wachol

Flutter is lately gaining more and more traction, but how is it in practice?
In this talk we will reflect on our 2 years long journey - what went well and what didn't and why we're still excited about it.
In this talk you will learn when Flutter can be useful for you and when to consider it for your next app.

Android MVI with Jetpack Compose

Luca
Nicoletti

A little intro on how Jetpack Compose will help use a real MVI approach in the Android world. Views will become dumber than ever!

Architecting Android and iOS app features for 2020

Kaushik
Gopal

Inspired by some well known architecture patterns like MVVM/MVI, I set out to come up with an agnostic set of principles that would help developers build features in their app in a robust, safe and (importantly) “testable” way. At Instacart, we've started to use these principles to build features on both iOS and Android.
In this talk, we'll examine these principles, discuss the merits (+ disadvantages!) and see how these can be implemented with precise code examples. Having implemented this pattern for sometime now at Instacart, I'll also share some of our learnings along the way for both platforms.
Eight years ago, when we started building Allegro for iOS, there was no Swift, our team was very small and no one thought about scaling the process. Since that time applications have grown significantly, have become more complex and now lots of teams have to deal with decisions that were taken when mobile app development was still a niche. This presentation is a subjective journey through changes in Allegro iOS application, resulting in breaking the monolith into module driven architecture. We will tell you how our architecture has evolved, how we’ve scaled our process, what we’ve improved and what did wrong. Everything with a dose of pragmatism and our experiences after successfully breaking the monolith on the backend and progressing it to microservice architecture. Showing that two different worlds of backend and mobile suffer due to the same fundamental problems when scaling up.

Building a CI/CD pipeline for your mobile app

Peter-John
Welcome

Mobile apps have evolved over the years and there is many components to starting a new projects and having working and maintainable software. Something that has become important to building good mobile apps is having a CI/CD pipeline. In this talk I will cover the different components needed to create a successful pipeline. This will include choosing a git strategy, a choice of static code analysis tools, unit testing and automatic deployments with Fastlane.

Cooking with Coroutine Recipes

Filip
Babić

Nishant
Srivastava

Kotlin Coroutines or Koroutines graduated to stable release just last year and are fairly new for everyone adopting them. That means a lot of the information is not quite straightforward when it comes to implementing them in current projects.
In this talk, you will be cooking up a hot pot of various Kotlin Coroutine approaches. You will be covering some aromatic recipes that provide step by step process to add that specific flavor to your current Kotlin and/or Android projects to unlock the full potential of Coroutines. By the end of the talk, you walk away with some really nice byte sized but complete usage approaches of Coroutines, solving daily problems in your current projects.

Core Data: Alive and Kicking

Abizer
Nasir

Core Data is Apple’s native framework for persisting data that works across all their platforms.
It has a reputation of being hard to use, not performant, and complicated to debug - many people have used other persistence methods such as SQLite or Realm.
But Over the past few years it has improved and continues to improve. A few years ago a method was introduced to more easy create stacks and use multiple threads for performance. At WWDC this year further changes were made to allow some storage in iCloud and also support with diffable data sources.
This will not be a beginner tutorial for Core Data. I propose to cover modern ways of working through best practices: - Setting up data sources, effective fetching of data from stores - Cloud storage, connecting to UITableViews/UICollectionViews through the new diffable data sources. How to bind SwiftUI Views to data.
Many people think that Core Data is unsupported and not a good solution for persistence. I will show how it is still relevant in modern application development and it is still Alive and Kicking.

Coroutines vs. ReactiveX: Handling errors

Milos
Marinkovic

Imagine you’re writing asynchronous code.
- Are you using callbacks? (no)
- Are you using Futures? Reactive streams?
- Are you using async features of your language of choice?
Whatever the answers are, you want to do error handling right. Let’s compare Coroutines and ReactiveX in this regard.
Whether you’re coming from the Android world or not, you’ve probably heard about Kotlin (the programming language) and its asynchronous programming concept called Coroutines. It’s a neat concept that helps you create execution blocks similar to light-weight threads, while at the same time allowing you to write your asynchronous code in a synchronous fashion.
On the other hand, many of us got really (really) used to Reactive Extensions in many languages, and we prefer to go down this road. With ReactiveX, you can chain your asynchronous blocks in future-like structures, and easily control threading around them.
Well, you know how it usually goes - you read about something (aha! what is this coroutines thing)… maybe you see a couple of talks on the topic, maybe you get interested. After you try it out and decide to use it in a real project, you start typing your code… and boom! Your program crashes. You then go to StackOverflow to check for answers to your problem, and surprise: you’re not handling errors properly. You copy-paste the solution without any edits or tests and you’re ready for release.
Hopefully this is not you. You want to check everything before using a new language or library, you want to fully understand the consequences of switching over to a different solution from the one you currently have. There are some quirks in every approach, sure, but do you know all of the corner cases?
That’s why we need to have this talk. Let’s go together through the most interesting examples of how we can get (and handle) errors with ReactiveX and Coroutines.

Functional Magic in Swift

Neem
Serra

Do you find yourself creating messy code in order to transform Swift optionals? Do you wish you harnessed the functional power of Swift more? This talk is for you! You’ll learn about creating elegant code with map and flatMap, and some tips and tricks to use this magic to make your code more Swifty.
Introduction

How I moved a large production app to Navigation Component

Piotr
Mądry

For some time, the Android team from Google has been providing us a new, attractive solutions to problems that every Android Developer will encounter sooner or later in his career.
One of such solutions is Navigation component, which simplify the implementation of the transition from screen to screen, and at the same time provide a tool that is an amiable to use and allows testing.
In my talk I would like to raise the question, whether this will work well in every project?
Why we decided to use Navigation component in our production app and how we dealt with problems on our way, as well as provide a knowledge about how to prepare for the migration from the current implementation to a new idea from Google.

How to build a messenger for Android?

Andrii
Rakhimov

It looks so simple outside, the app which can send messages from one user and receive from others. This is what we were thinking from start. 9 months passed we're still on it. In this talk, I will go through the main parts of the messenger project such as transport, synchronization, architecture, storage, pagination as well as explain common mistakes we've made on the way to instant messenger.
You’ll leave this talk with a solid understanding of how modern messengers are built and the confidence to get started.

How to start to writing autotests and not go crazy

Eugene
Matsyuk

The mobile world is growing and developing. Our applications are not only “to download from a server and to show in a list”. Our applications are big infrastructure, increasing the complexity of projects and the desire to release faster. And if we want stable and frequent releases then we need autotests. But. Autotests - is a good solution, no doubts. But where to begin? How do you write them? What underwater icebergs are waiting for us? In my speech, I want to describe how to start. Together we will go through:
  • history of the implementation of autotests in processes of the mobile department in KasperskyLab
  • choosing of appropriate tools
  • creating of code-style (yes-yes, autotest’s code is also a common program code)
  • our pain that we had and why we have created a new framework. And how this framework has made our life easier
  • How to write end-to-end tests with integration tests. How to make sure that your autotests start to work and that you receive the benefits as early as possible?
  • How have we made the process of creating screenshots light and fast?
I’m sure that after my speech you will not be afraid of autotests.

How to talk to computers

Mateusz
Figlewicz

A new line of thinking about interfacing with devices around human. Presentation will describe the possibilities, risks and challenges with voice communication both from design and ecosystem approach and implementation level.

How to test on you Flutter app

Dylan
Drost

Creating a cross platform app on Flutter is really efficient but can everything be tested and automated so you can create high quality apps. And if everything is test does run on IOS and Android as expected.

IAP Subscriptions - Lessons learned

Tomasz
Grynfelder-Renk

Traps, Tips and Tricks on implementing (auto-)renewable subscriptions with In-app purchase APIs on iOS.

Invest in tests - Unit testing iOS applications

Jayesh
Kawli

Unit tests is often forgotten part in a fast-paced culture. I will use my past experience and examples to teach why unit tests should be integrated into regular workflow. We will see how to write testable code with attention to test things that matter. We will discuss how to write unit tests that carry high value, spot potential bugs and pitfalls to avoid while trying to only test things that matter. The presentation will be accompanied by examples to demonstrate how writing testable code should not be regarded as a boring and discretionary task, but rather part of regular software development and how the choice of architecture makes a big difference in the test quality. Attendees of the session will take away the following:
  1. What exactly is unit testing and why should I worry about it?
  2. Unit tests as a tool to write quality code eventually leading to a reduced future maintenance cost for the codebase
  3. Code reviewing unit tests
  4. Demystifying the illusion of code coverage obsession.

Jump-starting with Swift UI

Timirah
James

SwiftUI is arguably the most exciting thing announced this year at WWDC. The new Apple framework has quickly become popular amongst developers, as a sleek new API for designing and writing code across all Apple platforms -- iOS, watchOS, MacOS, and tvOS!
In this talk, we’ll walk through examples and touch on all the basics to get you up and going with SwiftUI, including creating and combining views, state variables, experimenting with layouts such as HStack and VStack, dynamic lists, and more!

Kotlin Not-to-Do List - What we should avoid doing in Kotlin

Marcin
Moskala

Kotlin gives us a lot of possibilities, but with every power comes responsibility. What should we avoid doing in Kotlin? What are Kotlin internal contracts in terms of different features and functions? What is dangerous and should be avoided? How to code responsively?

Kotlin/Native and Multiplatform Development

Vipul
Shah

This workshop will introduced you to Kotlin/Native and build a Kotlin Multiplatform app that runs on both iOS and Android using shared Kotlin code. We will cover following topics in this workshop Introduction to Kotlin/Native and Multiplatform Your First Kotlin/Native Program Creating a Multiplatform Project Shared Library from Android & iOS Networking & Concurrency using Ktor & Coroutines Designing Android & iOS user interface Debugging multiplatform Project Drawbacks

MVVM as good (anti)pattern in iOS

Mateusz
Szklarek

Nowadays there are a lot of materials, presentations & talks about how great MVVM architecture is. Hype about the view models look like a never ending story. There are a lot of developers who like this approach and use it in their own projects. I tried to go against the grain and show a different perspective of MVVM. I also try to answer questions like: Do we really need it? Does it solves any particular problem or is it overkill?.

Make some move with MotionLayout

Alexandre
Genet

Always wanted to build better animations on Android ? Let’s explore Motion Layout in order to know its capabilities. MotionLayout beta-1 was release during the Google I/O. It promises to simplify the way we create animation on Android. Based on XML we will be able to describe on animation that could connected to a swipe on the screen or a native component.
In this talk, I will explore an Android app that list version of Android. For each version we will discover a new example, starting with basic modification of a constraint. Then adding KeyFrame with position, scale and rotation. Next playing with customs attributes to change the image color saturation. Lastly we will explore connection with Coordinator Layout, View Pager, Drawer and SeekBar.
At the end, you should know how to use and what are the capabilities of MotionLayout. Should you use it in your application ?
Want to know more, you can read this article : https://medium.com/xebia-france/move-my-app-with-motionlayout-part-1-7800637feb22

Mobile Visual testing with Vizzy

Raul
Portales

In this talk Raul will show how to configure and use Vizzy for visual testing your app (platform agnostic)
You have your UI tests, and they verify that a button with the right text is on screen... but how do you check that the style is consistent, or that the padding hasn't changed, or anything about the actual visual representation of the UI.
You can do it manually, but what if there were a tool that simplify that? That is what Vizzy does.

Structured unit testing with Spek

Martin
Petrulak

Are you tired of decrypting the JUnit test that you wrote a few weeks back? Do you want to write nice, readable & structured tests that are actually fun to write and joy to read? If you have answered yes to at least one of the questions above, I have a solution for you. Join this talk and fall again in love with unit testing. We will cover:
  • Describe how Spek works
  • Comparison with JUnit
  • Sample tests for a project following a clean architecture pattern (data, domain & view layer)

Tips & tricks for daily UI development

Pawel
Urbanowicz

Time spent on developing User Interfaces is often costly when it comes to mobile software development. It's also one of main reasons that led to the rise of cross-platform technologies. During this talk, I'd like to show you a couple of techniques how we can optimise UI development and maintain good code quality while working on 100% Swift and UIKit codebase.

Two Perspectives on iOS Accessibility

Milosz
Staszewski

Mateusz
Duc

During our talk, we would like to present two perspectives on implementing proper accessibility support on iOS. We will focus on visual impairment-related topics and try to clearly distinguish between efforts to technically meet the requirement of "providing accessibility support" and factually designing solutions that meet the needs of potential users. It is one thing to comply with the regulations, and other – to design and build really usable products.

Voyager - DI and Navigation for Flutter

Lukasz
Wisniewski

Voyager is the widget router. It combines yaml configuration map, custom plugins architecture and dependency injection into one comprehensive system that allows you to define readable requirements as code and turn them into flutter components.
If you have ever thought HOW MIGHT WE:
  • make deep links easy
  • make requirements trackable across git history and different branches
  • A/B test different navigation flows without code pollution
I might have some answers for you.

Xcode Project Generation

Kassem
Wridan

Managing large iOS projects, like building the Bloomberg Professional mobile application, can be challenging, as they can quickly run into scaling issues. This past year, the iOS Platform team at Bloomberg undertook a few initiatives to build out and use open source tooling to help manage their Xcode projects. This talk will cover some of the key insights and learnings from their experience on the nuances of Xcode projects. We'll see why project generation tooling may be needed and the landscape of tools out there.

Workshops

Creating robust Android UI tests

Alex
Zhukovich

Mobile apps are growing. They become more complex and require more testing. It means that it is time to integrate automated tests to your project inefficient way because they should be fast and stable. During this workshop, we will write a lot of test cases efficiently. We start with a fast introduction to Espresso and UiAutomator frameworks. Afterwards, we are moving to write different types of UI tests and finally, we create a DSL which helps us to write stable test cases with minimum noise..
To participate in this workshop purchase a separate ticket.

Kotlin Coroutines

Marcin
Moskala

The workshop covers asynchronous programming in Kotlin using coroutines. It covers both build-in support for coroutines and dives deeper into kotlinx.coroutines library. In the workshop we cover:
  • Styles of concurrence
  • Sequence builders
  • Continuation
  • Understanding how suspension works
  • Coroutine Context
  • Interceptors and dispatchers
  • Coroutine Scope
  • Coroutine builders
  • Structured concurrency
  • Understanding Job
  • Composing suspending functions
  • Exceptions handling
  • Shared mutable state and concurrency
  • Channels
  • Actors
  • Unit testing.
    To participate in this workshop purchase a separate ticket.
Venue and Info

Venue Details

Same as previous years, Mobilization IX is happening at the Expo Łódź, the largest organiser of trade shows, exhibitions, domestic and international conferences operating in central Poland.

Address:

EXPO-Łódź
al. Politechniki 4, 93-590 Łódź, Poland

Phone:

Marek Defeciński
+48 517 725 068

Contact Us

 

Marek Defeciński
+48 517 725 068