Reactive MVP - Giorgio Natili - Codemotion Rome 2017

@giorgionatili#DroidconBos - #MobileTea

Reactive MVP

About Me

+ Engineering Manager at Akamai (NG2 on desktop and mobile)

+ Founder of Mobile Tea (www.meetup.com/pro/mobiletea)

+ Organizer of DroidCon Boston (www.droidcon-boston.com)

Agenda

+ Model View Presenter

+ Functional Reactive Programming

+ RxJava and Multi Threading

+ RxKotlin

Before We Start

+ There is a slide that is a fake

+ Catch it and tweet it (hashtag #DroidconBos)

+ Win a free ticket to Droidcon Boston

Model View Presenter

Model View

Presenter

Original Design

Variations

The Presenter

Presenter Responsibilities

+ Manage the business logic

+ Handle the interaction between components

+ Orchestrator of behaviors and communication

Presenter Traits

+ A tiny class with a single responsibility

+ Optionally exposed trough an interface

+ Self independent and free from framework specific constraints

Testable

+ Methods should be easy to be tested

+ Optionally (but strongly encouraged) should return a value

The View

View Responsibilities

+ Rendering data on the screen

+ Handle user interaction

+ Consume behaviors trough the presenter

View Traits

+ A class that deals only with the presentation layer

+ Always exposed trough an interface to the presenter

+ Self independent but able to handle frameworks constraints

The Model

Model Responsibilities

+ Manage the domain entities of a software

+ Facilitate the interaction with specific domain entities

+ Abstract domain objects in the context of a specific view

Model Traits

+ Decoupled and, when possible, framework agnostic

+ Designed to manage concurrency

+ Easy to test without external dependencies

Designing the Model

Behaviors

+ Identify software behaviors

+ Group functionality by behavior

+ Consistent returned data types

Value Objects

+ Should represent a value in your system

+ Should describe the characteristics of a thing

+ Equality is not based upon identity

+ Should be immutable

Entities

+ Should have a unique identity

+ Should delegate behaviors to value objects and aggregates

Aggregates

+ A cluster of associated objects that are treated as a unit for the purpose of data change

+ A way to move as much as possible of the behavior away from the Entities within the aggregate -> into Value Objects

+ A place to define the consistency rules of Value Objects

Repositories

+ A mechanism for encapsulating storage, retrieval, and search behaviors which emulates a collection of objects

+ Usually injected in a Service

Equence

+ Prevent race conditions and data collisions

+ Unify domain objects in aggregates

Services

+ Services are always exposed as an interface, not for “swappability” or testability, but to expose a set of cohesive operations

+ Domain services are the coordinators, allowing higher level functionality between many different smaller parts.

Functional Reactive Programming

In a Nutshell

+ FRP is a programming paradigm

+ It focuses on reacting to streams of changes (data and events)

+ It favors function composition, avoidance of global state and side effects

FRP Use Cases

+ Processing user (tap, swipe, etc.) and system events (GPS, gyroscope, etc.)

+ Responding and processing any IO event (asynchronously)

+ Handling events and data pushed from other sources

+ Many, many, many others! : )

Observable<T>

+ An Observable represents a flowing stream of values

+ UI events

+ Data processed in background

+ The most similar abstraction is Iterable<T>

Pull vs Push

+ Observable is push based, it decides when to emit values

+ Iterable is pull based, it sits until the some ask for the next() value

Pull vs Push

Hot vs Cold Observables

+ A cold Observable is entirely lazy

+ Hot Observables might already be emitting events no matter how many Subscribers they have

+ Hot Observables occur when we have absolutely no control over the source of events (aka taps)

RxJava

In a Nutshell

+ It’s an implementation of the Reactive Extensions (Rx) on the JVM

+ In RxJava, events are modeled as observable streams to which observers are subscribed

+ Implement methods composibility to improve the management of complicated workflows

Create an Observable

Subscribe to Observable

Multithreading

+ The ability to run several functions of a single program simultaneously

+ Predominantly by utilizing several processors, but potentially, by time-sharing their resource requirements

Parallelization

+ A common question about RxJava is how to achieve parallelization, or emitting multiple items concurrently from an Observable

+ This definition breaks the Observable contract which states that onNext() must be called sequentially and never concurrently

RxJava Implementation

+ Version 2.0.5 introduced the ParallelFlowable API that allows parallel execution of a few select operators such as map, filter, concatMap, reduce and so on

+ Earlier versions introduced observeOn and subscribeOn to model parallel computations

subscribeOn()

+ The method subscribeOn() allows you to move the execution of the Observable code into another thread and with an specific behavior

observeOn()

+ The observeOn() method allows to specify where to execute the functions provided in the subscribe() one

Schedulers+ immediate(), creates and returns a Scheduler that executes work immediately on

the current thread

+ trampoline(), creates and returns a Scheduler that queues work on the current thread to be executed after the current work completes

+ newThread(), creates and returns a Scheduler that creates a new Thread for each unit of work

+ computation(), creates and returns a Scheduler intended for computational work

+ io(), creates and returns a Scheduler intended for 10-bound work (unbounded, multiple threads)

Kotlin

Why Kotlin+ Data classes

+ Inferred datatypes

+ Nullable types

+ Arguments default value

+ Lambda expression and “elvis” operator

+ Extension functions

Kotlin and the JVM

Nullable Types+ Nothing can be null in Kotlin until is not specified

Data Classes

Custom Getters

Lambdas+ Small chunks of code that can be passed to other functions

+ The ability to treat functions as values is part of the functional programming paradigm

Inline Functions + Default Values

+ Functions can be declared outside of a class and imported in others

+ Arguments can have default values reducing the number of methods overloads

High Order Functions+ A higher-order function is a function that takes functions as

parameters, or returns a function

Clean Architecture

Questions & Answers

Thanks!

Reactive MVP - Giorgio Natili - Codemotion Rome 2017

Technology

Rethinking enterprise software - Codemotion 2014

Codemotion workshop

REST in peace @ Codemotion 2011

Giorgio Natili - The Little Shop of TDD Horrors

Codemotion Milan 2015 Alerts Overload

Codemotion Warsaw 2016

Codemotion Rome 2014

Codemotion provinciali v. 0.1- Codemotion Rome 2015

David pilato codemotion-telaviv

Groovy programadores Java - Codemotion 2012

Nodeschool italy at codemotion

MongoDB dessi-codemotion

Real timeninja - Codemotion 2015 Roma

Presentazione Codemotion

Apache DeviceMap - codemotion Rome 2015

COMMEDIA COMICA IN DUE ATTI CCLLAAUUDDIIOO …copioni.corrierespettacolo.it/wp-content/uploads/2016/12/NATILI... · Commendatore Felice Mastrano padrone di casa (Claudio Natili) Assunta

Arquitecturas de microservicios - Codemotion 2014

Unethical JavaScript - Giorgio Natili - Codemotion Rome 2017

User stories writing - Codemotion 2013

Smau Napoli 2016 - Codemotion