Passionate about clean code and want to develop your knowledge of how to implement advanced architectures in Android applications? This three-day course 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 code in your platform, using a trusted codebase and with support and guidance from the instructor. Students will 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
- 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
This course is intended for android mobile app developers who would like to improve the way they build their products.
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
In order to attend this course delegates are required to bring their own laptop with the most recent version of Android Studio installed and running correctly.
If you are unable to bring your own laptop and you let us know at least 2 weeks prior to your attendance of this course, our team will be able to provide you with a laptop pre-installed with the above environment.