Are you an iOS developer who is passionate about clean architecture? Do you want to learn how to implement best principles and practices to build complex mobile applications without compromising on integrity and flexibility?
Do you want to learn how to implement best principles and practices to build complex mobile applications without compromising on integrity and flexibility?
Join this three-day virtual workshop to develop your theoretical and practical knowledge of advanced architectures in an iOS context.
Take an iterative and constructive approach to implementing applications and keep your code reusable, maintainable, testable and decoupled. Learn the required theoretical concepts of key architectural topics and use realistic application examples to implement features while understanding 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 a full-fledged iOS application on your computer, with the support and guidance of the instructor. You will also have access to the complete Swift code in a Git repository to review parts of the course at your will.
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 iOS mobile app developer who would like to improve the way you build your apps, by gaining a better understanding of clean code and advanced architecture practices this iOS Architecture course is for you!
Attendees should have (at the very least) 6 months of experience developing iOS applications (1 year preferred) and should be familiar with Swift 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
- (Micro)service architecture vs distributed architecture
- 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: Understand the initial responsibilities of the connector
- Memory Management: Implement the code so it follows the rules for good memory management and learn where to use weak so ARC can do its job
- 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 (using SwiftUI, storyboard segues or programmatically
- Modal vs Push: The implications of modal and push navigation and how to use them
- Dependency Injection
- Inversion of Control: How to use the mechanisms of the OS to inject the dependencies into the different view controllers
- 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 using SwiftUI and Combine mechanisms
- Third User Story: Detail
- Identity: The need and importance of identity
- Improve Reusability
- Command pattern: How it can be helpful and how to implement 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: Overcoming the problems associated with asynchronous work
- Asynchronous Entity Gateway: Implement an asynchronous repository using Combine
- 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
- Coexisting UIKit and SwiftUI