A hands-on workshop to understand the best practices of advanced architectures by implementing them in several use cases of a realistic application.

Overview

Passionate about clean code? Want to develop your knowledge of how to implement advanced architectures in Android applications? This three-day workshop follows an iterative and constructive path to build complex applications while keeping your code reusable, maintainable, testable and decoupled.

Learn the required theoretical concepts of key architectural topics and use realistic application examples to implement every feature using a step-by-step approach, and understand the principles that inform good architectural decisions, instead of using template implementations of solutions to problems.

This is a hands-on workshop, where you will write a full-fledged Android application on your computer with the support and guidance of the instructor. You will also have access to the complete Kotlin code in a Git repository to review parts of the course at your will.

Learn how to:

  • Write real-world applications using an advanced architecture

  • Target common concerns like concurrency and network API consumption

  • Create more reusable and fully testable code

  • Improve collaboration within your team and take advantage of multi-platform teams

  • Create code that is easier to debug and better suited to embrace the unexpected changes in newer iterations of the product

  • Create a Proof of Concept (PoC) without worrying about implementation details like the persistence method (SQLite, Room or any other), how to access the backend or even the particular views which will go into the final version of your app

  • Iterate from the PoC to get the minimum viable product extending the application with different modules

  • Write applications that are more independent from the frameworks they use, allowing for an easier replacement

  • Apply this knowledge to your current codebase

Audience

This course is intended for Android mobile app developers who would like to improve the way they build their products. Attendees should have at the very least 6 months of experience developing Android applications (1 year preferred) and should be familiar with Kotlin development, know object-oriented programming and what a design pattern is.

A Java version is also available.

Syllabus

Day 1

Architecture

  • Architecture is for you too: Problems that we can find when we write mobile applications and how a good architecture can help us

  • Using Design Patterns: A basic intro to design patterns and their value in writing good code

  • SOLID Principles: The five SOLID principles, their motivations, and how to apply them

Architectural Design Patterns (MVX): MVC, MVP, and MVVM

  • Rules to apply them properly

  • How to implement the architectural design patterns

Clean Architecture

  • Description and Pieces: The pieces that compose Clean Architecture and understand their purpose

  • The Dependency Rule: How to deal with dependencies properly in architecture

  • Hints for Implementation: How to start creating an application that uses this architecture

First User Story: Show List

  • Extract Minimum Viable Product: Plan the application we will write and how to approach the implementation of its features

  • Implement the Interactor (Business Logic): Create the type that will contain the business logic of the first user story

  • Implement the View Model: Creation of the model for the view that presents the data, provides the semantics to view events and uses the business logic

  • Implement the View: Write code for the view that the user will interact with

  • Implement the Entity Gateway: The needs of persistence and how to implement them

  • Connect the pieces and make it all work: Write the glue code so all the pieces of the first user story work as expected

Day 2

Connect the Pieces

  • Connect the pieces in a reusable way: The initial responsibilities of the connector

  • Memory management: Implement the code so it follows the rules for good memory management, and learn the need for WeakReferences and how to implement them

Modularization

  • Define the modules of the app and its responsibilities

  • Organizing the code: How to separate different pieces in packages

Navigation

  • Requirements in an advanced architecture

  • Implementation alternatives

  • Intents: How and where to create the intents and pass information to navigate

  • Fragment navigation using the Navigation Component

Dependency Injection

  • Use Koin to perform the dependency injection, implementing it in a way that the architecture is fully testable

Second User Story: Add

  • Presentation vs Domain Logic: The boundaries between the two types of logic and how they affect the implementation

  • Immutables: The implications of using immutables to model our data and how to do it, and implementation using reference types

  • Observation: Observation vs flow synchronization and when and how to implement them

Day 3

Third User Story: Detail

  • Identity: The need and importance of identity and how to implement it

Improve Reusability

  • Command pattern: How it can be helpful and how to use it

  • 2nd use case in the same view: Painlessly add a second case to the same view

  • Use case factories: The power of using factories and how to implement them to create use cases

  • Other use cases: Just Logic: Learn about use cases that are not related to persistence and how to model them

Asynchronous Work

  • Strategies for asynchronicity: Overcoming the problems associated with asynchronous work

  • Asynchronous entity gateway: Implement an asynchronous repository using coroutines

  • Other tasks: How other asynchronous tasks could be implemented

Suggested Additional Contents

  • Dagger 2: Implement dependency injection using Dagger 2 instead of Koin

  • Replace observation with Rx and its influence on the simplification of asynchronous work

  • Use coroutines for asynchronous work (Kotlin only)

  • Persistence factories: Implement multiple entities and relationships

  • Error handling: Deal with error at every layer of your application, logging and exposing

  • Clean Up Your App: Apply strategies to transform legacy code. How to migrate from your current codebase to a better architecture

  • Compose (declarative UI) version: Alone or co-existing with traditional UI

  • Basic unit testing of the different parts of the architecture (including the views)

  • Other scenarios: sensors, onboarding

Extras

A git code repository with all the code of the course is available on demand.

Requirements

Maximize the outcome of this course by bringing your laptop with the most recent version of Android Studio ready and write the code with us!

Related Courses

Overview

Is your app developed for iOS and Android? Do you want to apply the best architecture to both? This three-day workshop follows an iterative and constructive path to build complex applications while keeping your code reusable, maintainable, testable and decoupled.

Learn the required theoretical concepts of key architectural topics and use them building every feature of a realistic application using a step-by-step approach, and understand the principles that inform good architectural decisions, instead of using template implementations of solutions to problems.

This is a hands-on workshop, where each developer will write code for her platform of choice, while we will share the code for both platforms. The instructor will explain the concepts for Android and iOS and the differences between them and provides guidance on how to write both codebases. Attendees may have access to a Git code repository so that they can flexibly review parts of the course as they learn.

Learn how to:

  • Implement an application using an advanced architecture

  • Write real-world applications that use advanced architecture

  • Target common concerns like concurrency and network API consumption

  • Create more reusable and fully testable code

  • Improve collaboration within your team and take advantage of multi-platform teams

  • Create code that is easier to debug and better suited to embrace the unexpected changes in newer iterations of the product

  • Create a Proof of Concept (PoC) without worrying about implementation details like the persistence method (Core Data, Room or any other), how to access the backend or even the particular views which will go into the final version of your app

  • Iterate from the PoC to get the minimum viable product extending the application with different modules

  • Write applications that are more independent from the frameworks they use, allowing for an easier replacement

  • Apply this knowledge to your current codebase

Audience

This course is intended for Android & iOS mobile app developers who would like to improve the way they build their products. Attendees should have at the very least 6 months of experience developing iOS or Android applications (1 year preferred) and should be familiar with Swift or Kotlin development, know object-oriented programming and what a design pattern is.

Syllabus

Day 1

Architecture

  • Architecture is for you too: Problems that we can find when we write mobile applications and how a good architecture can help us

  • Using Design Patterns: A basic intro to design patterns and their value in writing good code

  • SOLID Principles: The five SOLID principles, their motivations, and how to apply them

Architectural Design Patterns (MVX): MVC, MVP, and MVVM

  • Rules to apply them properly

  • How to implement the architectural design patterns

Clean Architecture

  • Description and Pieces: The pieces that compose Clean Architecture and understand their purpose

  • The Dependency Rule: How to deal with dependencies properly in architecture

  • Hints for Implementation: How to start creating an application that uses this architecture

First User Story: Show List

  • Extract Minimum Viable Product: Plan the application we will write and how to approach the implementation of its features

  • Implement the Interactor (Business Logic): Create the type that will contain the business logic of the first user story

  • Implement the View Model: Creation of the model for the view that presents the data, provides the semantics to view events and uses the business logic

  • Implement the View: Write code for the view that the user will interact with

  • Implement the Entity Gateway: The needs of persistence and how to implement them

  • Connect the pieces and make it all work: Write the glue code so all the pieces of the first user story work as expected

Day 2

Connect the Pieces

  • Connect the pieces in a reusable way: The initial responsibilities of the connector

  • Memory management: Implement the code so it follows the rules for good memory management and learn:

    • (Android) the need for WeakReferences and how to implement them

    • (iOS) where to use weak so ARC can do its job

Modularization

  • Define the modules of the app and its responsibilities

  • Organizing the code: How to separate different pieces in packages

Navigation

  • Requirements in an advanced architecture

  • Implementation alternatives

    • (Android) Intents: How and where to create the intents and pass information to navigate

    • (Android) Fragment navigation using the Navigation Component

    • (iOS) Use SwiftUI, storyboard segues or programmatically

    • (iOS) Modal vs Push: The implications of modal and push navigation and how to use them

Dependency Injection

  • (Android) Use Koin to perform the dependency injection, implementing it in a way that the architecture is fully testable

  • (iOS) Inversion of control: How to use the mechanisms of the OS to inject the dependencies into the different view controllers

Second User Story: Add

  • Presentation vs Domain Logic: The boundaries between the two types of logic and how they affect the implementation

  • Immutables: The implications of using immutables to model our data and how to do it, and implementation using reference types

  • Observation: Observation vs flow synchronization and when and how to implement them

Day 3

Third User Story: Detail

  • Identity: The need and importance of identity and how to implement it

Improve Reusability

  • Command pattern: How can it be helpful and how to use it

  • 2nd use case in the same view: Painlessly add a second case to the same view

  • Use case factories: The power of using factories and how to implement them to create use cases

  • Other use cases: Just logic: Learn about use cases that are not related to persistence and how to model them

Asynchronous Work

  • Strategies for Asynchronicity: Overcoming the problems associated with asynchronous work

  • Asynchronous entity gateway: Implement an asynchronous repository

  • Other tasks: How other asynchronous tasks could be implemented

Suggested Additional Contents

  • (Android) Dagger 2: Implement dependency injection using Dagger 2 instead of Koin

  • (Android) Use coroutines for asynchronous work

  • Replace observation with Rx and its influence on the simplification of asynchronous work

  • Persistence factories: Implement multiple entities and relationships

  • Error handling: Deal with error at every layer of your application, logging and exposing

  • Clean up your app: Apply strategies to transform legacy code. How to migrate from your current codebase to a better architecture

  • Compose(Android)/SwiftUI(iOS) (declarative UI) version: Alone or co-existing with traditional UI

  • Basic unit testing of the different parts of the architecture (including the views)

  • Other scenarios: sensors, onboarding

Extras

A git code repository with all the code of the course is available on demand.

Requirements

Maximize the outcome of this course by bringing your laptop with the most recent version of Android Studio or Xcode ready and write the code with us!

Related Courses

Overview

Are you an iOS developer who is passionate about clean architecture and wants to learn how to implement best principles and practices to build complex mobile applications without compromising on integrity and flexibility? This three-day workshop will develop your theoretical and practical knowledge of advanced architectures in an iOS context.

Take an iterative and constructive approach to implementing applications and keep your code reusable, maintainable, testable and decoupled. Learn the required theoretical concepts of key architectural topics and use realistic application examples to implement features while understanding the principles that inform good architectural decisions, instead of using template implementations of solutions to problems.

This is a hands-on workshop, where you will write a full-fledged iOS application on your computer with the support and guidance of the instructor. You will also have access to the complete Swift code in a Git repository to review parts of the course at your will.

Learn how to:

  • Write real-world applications using an advanced architecture

  • Target common concerns like concurrency and network API consumption

  • Create more reusable and fully testable code

  • Improve collaboration within your team and take advantage of multi-platform teams

  • Create code that is easier to debug and better suited to embrace the unexpected changes in newer iterations of the product

  • Create a Proof of Concept (PoC) without worrying about implementation details like the persistence method (Core Data, Realm or any other), how to access the backend, which user stories will be shared with the watch version of the app or even the Apple TV app, or even the particular views which will go into the final version of your app

  • Iterate from the PoC to get the minimum viable product extending the application with different modules

  • Write applications that are more independent from the frameworks they use, allowing for an easier replacement

  • Apply this knowledge to your current codebase

Audience

This course is intended for iOS mobile app developers who would like to improve the way they build their products. Attendees should have at the very least 6 months of experience developing iOS applications (1 year preferred) and should be familiar with Swift development, know object-oriented programming and what a design pattern is.

An Objective-C version could be also available.

Syllabus

Day 1

Architecture

  • Architecture is for you too: Problems that we can find when we write mobile applications and how a good architecture can help us

  • Using Design Patterns: A basic intro to design patterns and their value in writing good code

  • SOLID Principles: The five SOLID principles, their motivations, and how to apply them

Architectural Design Patterns (MVX): MVC, MVP, and MVVM

  • Rules to apply them properly

  • How to implement the architectural design patterns

Clean Architecture

  • Description and Pieces: The pieces that compose Clean Architecture and understand their purpose

  • The Dependency Rule: How to deal with dependencies properly in architecture

  • Hints for Implementation: How to start creating an application that uses this architecture

First User Story: Show List

  • Extract Minimum Viable Product: Plan the application we will write and how to approach the implementation of its features

  • Implement the Interactor (Business Logic): Create the type that will contain the business logic of the first user story

  • Implement the View Model: Creation of the model for the view that presents the data, provides the semantics to view events and uses the business logic. Constraints of the Android View Model Architecture Component

  • Implement the View: Write code for the view that the user will interact with

  • Implement independent (and previewable) views with SwiftUI

  • Implement the Entity Gateway: The needs of persistence and how to implement them

  • Connect the pieces and make it all work: Write the glue code so all the pieces of the first user story work as expected

Day 2

Connect the Pieces

  • Connect the pieces in a reusable way: The initial responsibilities of the connector

  • Memory management: Implement the code so it follows the rules for good memory management and learn where to use weak so ARC can do its job

Modularization

  • Define the modules of the app and its responsibilities

  • Organizing the code: How to separate different pieces in packages

Navigation

  • Requirements in an advanced architecture

  • Implementation alternatives (using SwiftUI, storyboard segues or programmatically)

  • Modal vs push: The implications of modal and push navigation and how to use them

Dependency Injection

  • Inversion of control: How to use the mechanisms of the OS to inject the dependencies into the different view controllers

Second User Story: Add

  • Presentation vs Domain Logic: The boundaries between the two types of logic and how that affects the implementation (What to put in SwiftUI)

  • Immutables: The implications of using immutables with value types to model our data and how to do it, and implementation using reference types

  • Observation: Observation vs flow synchronization and when and how to implement them using SwiftUI and Combine mechanisms

Day 3

Third User Story: Detail

  • Identity: The need and importance of identity and how to implement it

Improve Reusability

  • Command pattern: How it can be helpful and how to use it

  • 2nd use case in the same view: Painlessly add a second case to the same view

  • Use case factories: The power of using factories and how to implement them to create use cases

  • Other use cases: Just logic: Learn about use cases that are not related to persistence and how to model them

Asynchronous Work

  • Strategies for asynchronicity: Overcoming the problems associated with asynchronous work

  • Asynchronous entity gateway: Implement an asynchronous repository using Combine

  • Other tasks: How other asynchronous tasks could be implemented

Suggested Additional Contents

  • Replace observation with Rx and its influence on the simplification of asynchronous work

  • Persistence factories: Implement multiple entities and relationships

  • Error handling: Deal with error at every layer of your application, logging and exposing

  • Clean up your app: Apply strategies to transform legacy code. How to migrate from your current codebase to a better architecture

  • UIKit version: Alone or co-existing with SwiftUI

  • Basic unit testing of the different parts of the architecture (including the views)

  • Other scenarios: sensors, onboarding

Extras

A git code repository with all the code of the course is available on demand.

Requirements

Maximize the outcome of this course by bringing your laptop with the most recent version of Xcode ready and write the code with us!

Related Courses