Are you an android developer keen to take your mobile aps 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 Pattnerns, 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
- 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
- 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
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
- 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
- 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
- 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'll need a laptop to participate in the labs and exercises that are part of this course, and are invited to bring your own. This way you can learn using an environment you are used to, your preferred tools, languages and IDE, so you can focus on learning the new concepts and skills covered in this course.
Please also 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 and you let us know as soon upon booking and at least 1 week prior to your attendance of this course, and our team can provide you with a laptop that is pre-installed with any relevant environment.