Fast Track to Android Architecture

Topics covered at ANDROID-ARCHITECTURE-01-03
View Schedule & Book More dates available

Next up:


Are you an android developer keen to take your mobile apps to the next level by designing more flexible decoupled architectures and by writing cleaner, reusable, maintainable, testable and decoupled code? Join this Android Architecture course and learn the principles that inform good architectural decisions, how to adopt Architectural Paradigms, SOLID Principles, Clean Architecture concepts and Design Patterns, to create more flexible and performant applications with cleaner, reusable, maintainable, testable and decoupled code.

This is a highly practical course with a workshop style format, so you can learn by applying best practices to a clean and trusted code base first, and then to your own current project, in three days of lectures, discussions and exercises. You will have access to a Git code repository so that you can flexibly review parts of the course as you learn and will write code in your own environment, but using a trusted codebase, and with support and guidance from Jorge throughout the three days.

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
  • Projects collaboration other members
  • 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, or even the particular views which will go into the final version of your app
  • Iterate from the PoC to get the MVP 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

About the Author

Jorge Ortiz Fuentes

Jorge is a freelancer dedicated to mobile development, security, and systems architecture. He started his work as a developer at M.I.T. in 1993 and since has collaborated in numerous software projects. Most of them were internally for HP where he worked for more than 15 years. Since 2008 he has been working in different aspects of mobile development. After playing with PalmOS, he learned Android programming for the first Google App contest and immediately started to play with the first iPhone SDK. He is an instructor in the best iOS and Android Bootcamps in the USA and Europe, and has spoken at some of the world's most renowned conferences about topics relating to mobile app architecture and best practices (and occasionally about Go and Raspberry Pis).


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
    • Architectural Paradigms (MVX): MVC, MVP, and MVVM, the rules to apply them properly, and how to implement them
    • SOLID Principles: The five SOLID principles, their motivations, and how to apply them
    • Using Design Patterns: A basic intro to design patterns and their value in writing good code

  • 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 that we are going to 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 Presenter: Create a presenter that provides the semantics to view events and uses 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 the need for WeakReferences and how to implement them
    • Navigation: How to implement navigation in an advanced architecture
    • Intents: How and where to create the intents and pass information in order to navigate
  • Dependency Injection
    • Service Locator (Dagger 2): Use Dagger 2 to perform the dependency injection, implementing in a way that the architecture is fully testable
  • Second User Story: Add
    • Organizing the code: How to separate different pieces in packages
    • Presentation vs Domain Logic: The boundaries between the two types of logic and how they affect 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
  • Implement the Third User Story: Detail
    • Identity: The need an importance of identity and how to implement it
    • Command pattern: How the command pattern can be helpful and how to use it

Day 3

  • Improve Reusability
    • Use Case Factories: The power of using factories and how to implement them to create use cases
    • 2nd Use Case in the Same View: Add a second case to the same view without hassle
    • 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: The problems associated with asynchronous work and how to overcome them
    • Asynchronous Entity Gateway: Implement an synchronous repository
    • Other tasks: How other asynchronous tasks could be implemented
  • Clean Up Your App
    • Strategies to Transform Legacy Code: How to migrate from your current codebase to a better architecture



If you are an mobile or android developer, and you would like to improve the way you build your apps, by gaining a better understanding of clean code and clean architecture practices, concurrency, performance and network API consumption, this Android Architecture course is for you!


Attendees should have at least 1 year of experience developing Android applications, and should be familiar with Java and/or Kotlin development and know object-oriented programming and what a design pattern is.

Bring your own hardware

You are invited to bring your own laptop to this course so that you can learn using an environment you are used to, your preferred tools, languages and IDE, and can focus on learning the new concepts and skills covered in this course.

Please make sure you'll have the most recent version of Android Studio installed and running, prior to your attendance. A Git code repository will be made available for your use during the course, and can be downloaded at the event.

If you are unable to bring your own laptop please let us know at least 2 weeks prior to your attendance of this course so that our team can assist.