Topics

NSURLSession completion handler has 3 optional types giving us 8 permutations when all we care is either it failed or succeeded. Error handling is still neglected for the fact that Swift does not provide a construct that abstracts the rudimentary details of switch and conditionals. Most Objects and their associated methods are not composable.

Monadic Computation comes from Functional Programming which helps write composable functions while preserving failure context/side effects and provide better abstraction. Swift although not a functional programming language, can express monadic computations elegantly and can solve all the above-mentioned problems.

In the talk, I will show why do we need Monadic Computations and how we can implement in Swift. I will share real use case of monadic computations and how our team at Zalando is using this concept. There will be a short live coding to demonstrate that Monadic Computation can be expressed elegantly in Swift.

There is a lot of Hype with ML and AI lately, and TensorFlow is the framework of choice from Google. But as a Mobile Developer you might have asked yourself, how can I benefit from it? In this talk, you will learn your first steps into the fascinating ML world for mobile.

During this talk you will learn how to set up TensorFlow for Android, and how to perform some initial operations with it:

• Classifying example
• Detection example
• Analyzing example

When new technologies start gaining momentum in the Android community, the pragmatic (or lazy) among us eventually have to ask ourselves, “Is it worth it?” After the initial arrival and departure of the hype train, some of these become trusted tools we use in almost every app. Think RxJava and Dagger.

React Native may be on its way to earning a place in the same club. Once we get past the fact that JavaScript on Android and HTML in JavaScript seem pretty damn weird at first, there’s a lot to like. Seeing your changes on a device almost instantly is a love-at-first-sight kind of thing. And rethinking your app architecture as a series of actions, state changes, and UI render phases can eliminate a surprising number of silly bugs.

A dive into every new technology starts with the flashy “type these commands and run your ‘Hello World’ app” tutorial. This is not that kind of talk. Instead, I’ll recap my experience digging into React Native for real world use. From integrating RN code into an existing Java/Kotlin app to dealing with the kind of problems they never mention in the README, I’ll cover what you need to know to decide if React Native is really worth your time. 

Enrique Lopez Manas, GDE and a transitioner among all those categories, will share his experience in this world and give you some tips if you are opting for changing your career. You will learn about the bright and not so bright side of contracting, the perks you can expect in each category, and especially being able to fire questions to a person that has been in the transition among both fields.

What are the differences between being permanent and contract? What are the perks of each position? How can you make a transition between them? Which fits me better? If you ever asked those questions to yourself, you will find some answers in this talk. 

State can be a tricky thing in every system specially when’s manipulated in different places, causes some side-effects, … On mobile apps, it can be especially challenging when we have highly dynamic user interfaces driven by some state(s) and a great example of that are forms where is frequent to see some collapsable rows or entire sections being inserted, removed or even both. Manually managing all of that can be quite complex and most of the times ends up not being sufficiently generic to be reused by every form which increases the effort of not only developing but also maintaining each form within an app. And if that was not enough, there's also the question of reading and understanding precisely the structure of a single form which most of the times are imperative and composed by many components, e.g. delegates, data sources, ..., making it even more hard to maintain and modify. FormsKit born as a need to manage a reasonable number of forms in a declarative and composable way through a descriptive state.

FormsKit follows a React-based approach to render and manage a form through a virtual representation which is completely driven by any change in a single core state. This enables deriving an interface for a very specific state instead of patching it manually which requires knowledge of the current state of the form, which can actually be many combinations, to then determine the correspondent transition to reflect the new state. FRP plays an essential role as the base to track any change in the core state and consequently triggering a new form's representation plus notify those changes as a stream of values. 

Despite the focus in FormsKit framework, the main goal is to demonstrate how we should change our way of thinking to derive interfaces, and even other states, through a single state instead of doing the other way around, avoiding manual and localised changes which are not easy to understand, maintain and finally test.

Do you want to build backend applications using Swift but don't want to manage computing infrastructure to run those applications in the cloud? Enter serverless cloud platforms… 

These services allow developers to push code, rather than VMs, into the cloud. The platforms allow you to connect external event sources like API requests or message queues to functions in your code. As events occur, your code is instantiated and executed to process each request. Developers are only billed for the milliseconds needed to process each request.

In this session, developers will learn how to build Swift microservices using modern “serverless” cloud platforms. We’ll look at common challenges (and solutions) to building applications using “serverless” stacks. Exploring emerging “serverless” design patterns will give developers the knowledge to build application architectures using these new platforms.

My talk will be split into three sections:

1. An introduction as the background of serverless computing platforms. What are they, why would you use them and what benefits do they bring over other cloud technologies likes IaaS, Containers or Paas. 
2. The middle is then a "live coding" session using one of these platforms to build a real Swift backend application (serverless apis to create a slackbot) to show developers the techniques and skills for building serverless applications through a real world demonstration. I'll build the application, deploy to the cloud and get it running in under twenty minutes from scratch.
3. Finally, I finish looking at the challenges of serverless development today. What are the difficulties? Monitoring, debugging, etc.... and introduce some workarounds or solutions. 

At Google I/O we got the Android architecture components. One of its most interesting concepts in there is the new ViewModel.

This sounds like a perfect fit into the MVVM (Model View ViewModel) architecture. What’s the idea of MVVM? How does it fit into the new architecture components? And what's the role of Android databinding here?

Kotlin is here and some Architecture Patterns need to be adapted.

From Karumi we've dedicated last 3 years talking about architecture and design patterns, each solution has pros and cons and could be good for different problems and kind of applications.

Kotlin brings to us different tools and ways to write code these can help to us to write different patterns or apply different technics to that patterns.

In this talk, we present some commons problems in app designs and how we can provide solutions in Kotlin.

So you started to use MVP in order to make your code be more testable and better separated. However, some of your views have multiple actions that can be performed by the user making your presenter to reach couple of hundred of lines of code. During this presentation Mateusz will tell you some details of how they started to structure their code in order to make whole your presentation layer look better.

During this talk I will prove that the only way of keeping your presenters small is to keep your views small as well. We will discuss possible ways of splitting complex views into analityk pieces and what were different international of doing so im my projects.

Apple took everyone by surprise at WWDC introducing ARKit, a framework that helps developers create augmented reality experiences for their users by adding virtual objects and information to the real world. Probably the biggest software-only breakthrough in recent iOS updates, ARKit is still new, but we have all already seen demos of what it can do. There are lots of possible use cases for it, and it's up to us to create awesome experiences for our users with ARKit.

In this talk, I will give a small intro to ARKit and show how to make your first ARKit app. We'll look at how to enable ARKit in your app, possible use cases of ARKit and go through some tips and tricks.

The mobile devices of the latest generation are now capable of powering the desktop user experience. Get your Android apps ready for the big screen. Learn what it takes to optimize your apps for enhanced interactions, desktop mode capabilities, and an overall amplified in-app experience.

Stay for the quiz and for a Samsung DeX station giveaway at the end of the session!

Below are the main talking points:

1. Choosing a pattern
2. Why using Clean Architecture
3. Migrating legacy code
4. Architecture vs quick implementation
5. Profits
6. Project evolution

During this talk, I am going to share Petcube experience on apps architecture, our struggles with finding a balance between quality of architecture and speed of product implementation.

Augmented reality (AR) is one of the hottest trends in tech these days because this area is quite pure and young with huge opportunities in the future. AR was one of the key features in lately presented smartphones from giants Google and Apple. This promising technology will change the industry of mobile devices.

I am going to tell about first steps in AR on Android, the biggest challenges during development and how to research a new technology in a few months. During the talk, I will show interesting demo, useful showcases and tell a story about my summer trip to San Diego and how they work. Why code style is so important in a big project and how much attention they pay to architecture design.

Modern programming can not be imagined without long-running operations such as CPU-intensive computations or blocking IO running in the background. Unfortunately, having too many active threads is very expensive and kills performance, but there's a solution - coroutines. They provide a way to avoid blocking a thread and replace it with a cheaper and more controllable operation: suspension of a coroutine.

I'll talk about generators/yield, async/await, channels, composable/delimited continuations, and its usage; consider available APIs and make the overview of standard kotlinx.coroutines library.