Advanced Architectures in Android
This course is designed as an iterative and constructive
approach to advanced architectures in Android. It uses a
realistic application as an example and it implements every
feature using a step by step approach after introducing all the
required theoretical concepts. It is intended for programmers
with at least 1 year of experience developing Android applications.
It is assumed that attendees are familiar with the basics of
Java development and know object-oriented programming and basic
design patterns such as delegation, Model-View-Controller or
singleton, among others.
This is a hands on training, where attendees write code to test
all of the concepts under the supervision of the instructor. As
an attendee, you would get access to a Git code repository with
all the code in Java that should be implemented during the
training with very granular commits. This adds flexibility to
review parts of the course from a trusted codebase and provides
a reference to compare your code.
An on premises version for both
Android and iOS is available upon request.
- 10 people maximum.
- Three days: same day of the week of consecutive weeks.
- Content (instructor explanations, slides, & live coding)
- Chat room and groups running during
the sessions that can be used to ask questions while the
instructor explains and to talk to your fellow attendees about
the exercises or other related topics.
- Access to the complete repo with many granular commits and unit
tests coverage > 95%
- Access to the slides
- Additional exercises for the attendee
- Four blocks of 1,5h per day. Additional time for
exercises. Uncommitted time for questions. Ask as much as
- Take 200€ off, if you reserve before the early bird deadline!
- Discount in other services when purchased together.
As a result of attending the course, students will:
- Understand the principles that allow to take good decisions
about architecture, instead of template implementations of
solutions to problems.
- Obtain an in depth knowledge on how to implement an
application using an advanced architecture.
- Be able to write real world applications that use an advanced
architecture and cover the most common concerns like
concurrency or network API consumption.
- Create more reusable and fully testable code.
- Collaborate in projects with other members of the team,
without stepping on each other's toes.
- Create code that is easier to debug and better suited to
embrace the unexpected changes in newer iterations of the product.
- Create a Prove 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 one, or even the particular views that will
go into the final version of your app.
- Iterate from the PoC to get to the Minimum Viable Product
extending the application with different modules.
- Understand how to write applications that are more
independent from the frameworks they use, allowing for an
easier replacement in case of need.
- Apply this knowledge to your current codebase.
- Architecture is for you too
- Architectural Paradigms (MVX)
- SOLID Principles
- Using Design Patterns
The Clean Architecture
- Description and pieces
- The Dependency Rule
- Hints for implementation
First User Story: Show List
- Extract Minimum Viable Product
- Implement the Interactor: Business Logic
- Implement the Presenter
- Implement the View
- Implement the Entity Gateway
- Connect the Pieces and Make it all Work
Connect the Pieces
- Connect the pieces in a reusable way
- Memory Management
- Dependency Injection: Service Locator (Dagger 2)s
- Preserving State
Second User Story: Add
- Organize the code
- Presentation vs Domain logic
Implement the Third User Story: Detail
- Command pattern
- Use Case Factories
- 2nd Use Case in the Same View
- Other Use Cases: Just Logic
- Forward Flow Synchronization
- Strategies for asynchronicity
- Asynchronous Entity Gateway
- Other tasks
Clean Up Your App
- Strategies to Transform Legacy Code