Are you an Android developer keen to take your mobile apps to the next level?
Are you interested in designing more flexible decoupled architectures? Do you want to write cleaner, reusable, maintainable, testable and decoupled code?
If so, join this virtual course on Android Architecture to discover the principles that inform good architectural decisions. You'll learn how to adopt Architectural Paradigms, SOLID Principles, Clean Architecture concepts and Design Patterns, and 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:
This intensive course will cover:
- Write real world applications using an advanced architecture
- Target common issues 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 unexpected changes in newer iterations of a product
- Iterate from the PoC to get to 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 in case of need
- Apply this knowledge to your current codebase
Available datesDates coming soon
Our team is happy to discuss other options with you.
Contact us at firstname.lastname@example.org and mention ref:
Private tuition and large-group discounts are also available. Find out more here.
Who should take this workshop?
If you are an Android developer, and you would like to improve the way you build your apps, by gaining a better understanding of clean code and advanced architecture practices, this Android Architecture course is for you!
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.
- Architecture is for you too: How a good architecture can help us solve the problems that we find when we write mobile apps
- 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 them
- Clean Architecture
- Description and Pieces: The pieces that compose clean architecture and their purpose
- The Dependency Rule: How to deal with dependencies properly in an architecture
- Hints for Implementation: How to start creating an application that uses clean 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 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
- 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
- Define the modules of the app and its responsibilities
- Organizing the code: How to separate different pieces in packages
- 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 that affects implementation
- Immutables: Learn the implications of using immutables with value types to model our data and how to do it
- Observation: Observation vs flow synchronisation and when and how to implement them
- Dependency Injection
- Third User Story: Detail
- Improve Reusability
- Command pattern: How it can be helpful and how to use it
- 2nd use case in the same view: Add a second use case to the same view without hassle
- Use Case Factories: The power of using factories and how to implement them to create use cases
- Other Use Cases: Just Logic: Use cases which 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 asynchronous repository using Combine
- Other Tasks: How other asynchronous tasks could be implemented
- Async Communications: Publish/Subscribe
- Messaging: Concepts and standards
- Message Brokers vs Brokerless
- Implement messaging
- Clean Up Your App
- Strategies to transform legacy code: How to migrate from your current codebase to a better architecture