Are you an iOS developer who is passionate about clean architecture and wants to learn how to implement best principles and practices to build complex mobile applications without compromising on integrity and flexibility? Join this three-day 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 code in your platform, using a trusted Swift 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:
- Write real world applications using an advanced architecture
- Target common issues like concurrency and network API consumption
- Create more reusable and fully testable code
- Collaborate in multi-platform teams
- Create code that is easier to debug and better suited to embrace unexpected changes in newer iterations of a 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 app, and 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: How a good architecture can help us solve the problems that we find when we write mobile apps
- 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 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 MVP: 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 Presenter: Create a presenter that provides the semantics to view events and uses business logic
- Implement the Entity Gateway: Understand the needs of the 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
- Navigation: How to implement navigation in an advanced architecture
- Modal vs Push: The implications of modal and push navigation and how to use them
- Inversion of Control: How to use the mechanisms of the OS to inject the dependencies into the different view controllers
Second User Story: Add
- Organise the Code: Hot to separate the different pieces into groups and holders
- Presentation vs Domain Logic: The boundaries between the two types of logic and how that affects implementation
- Immutables: Learn the implications of using immmutables with value types to model our data and how to do it
- Observation: Observation vs flow synchronisation and when and how to implement them
Third User Story: Detail
- Identity: The need an importance of identity
- Command Pattern: How the command patterns can be helpful and how to implement 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 use case to the same view without hassle
- Other Use Cases: Just Logic: Use cases which are not related to persistence and how to model them
- Strategies for Asynchronicity: Overcoming the problems associated with asynchronous work
- Asynchronous Entity Gateway: Implement an asynchronous 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 iOS mobile app developer who would like to improve the way they build their products then this course is for you!
This course is intended for programmers with at least 1 year of experience developing iOS applications. It assumes that attendees are familiar with the basics of Swift development and object-oriented programming, and know what a design pattern is.
Bring your own hardware
In order to attend this course delegates are required to bring their own Mac with most recent version of Xcode installed and running correctly.
Unfortunately Skills Matter will not be able to provide rental laptops for this course.