Ever wish you could become a better engineer without reading very long blog posts or watching lectures on Youtube? Introducing Swift Architecture RPG, coming soon.

Swift Architecture RPG is a self-paced, online, interactive experience to help you learn about software architecture. Benefits:

  1. Gamified, structured path to level-up and become an architecture expert
  2. Write real code, get feedback, guidance, and answers immediately
  3. Designed for both beginners and experienced engineers alike

Key Topics

  1. Design Patterns
    a. Decorator
    b. Observer
    c. Singleton
    d. Iterator
    e. Composite
    f. and more!
  2. Architecture Patterns
    a. MVC
    b. MVVM
    c. and more!
  3. Other Architecture Topics
    a. Reactivity
    b. Dependency Injection
    c. and more!

Design Patterns

Design patterns provide a standard way to solve common software problems. Design patterns are especially useful when working with complex and/or large code bases. Some of the design patterns included are:

Decorators enable new functionality while keeping the same interface.

Observers can help many objects keep track of changes to a specific state. Learn how observers are often used to manage complexity in apps.

Singletons ensure there is only one instance of an object. If you've built an app before, you have interacted with singletons!

Iterators provide a way to access elements of a sequence without providing access to the underlying representation.

Composites enable small, modular components to be composed to create more complex objects and interfaces. Learn how composites are used through app and app UI implementation.

Architecture Patterns

Understanding architecture will help you identify and avoid common software pitfalls and design errors. Some of the architecture topics included are:

MVC, Model-View-Controller, is an architectural pattern that separates an app’s data model from its user interface to making developing, testing, and maintain apps easier over time. MVC is a valuable iOS architecture pattern because:

  1. UI and business logic code is kept separate
  2. business logic can be tested without launching the UI
  3. code can be better resued through shared models

MVVM, Model-View-ViewModel, is an architecture pattern that separates the view and the view model. The view model is responsible for exposing data to the view and for handling any UI logic. The view is responsible for displaying the data and for handling user input. By decoupling the view from the view model, one benefit is the view model can be tested in isolation without having to launch the entire app.

Other Architecture Topics

Understanding how to build great apps goes beyond knowing about the key architecture and design patterns in Swift. Knowing when to apply patterns, the types of problems they solve, and the benefits / tradeoffs of each one will help you build better apps. Some of the additional topics included are:

Reactivity is a pattern used to help manage and respond to events.

Dependency injection is a technique where interfaces are used to enable objects to be created from loosely coupled components improving code resuability and testing.

Swift Architecture RPG

Are you ready to become a better engineer by learning about architecture and design patterns in Swift in a fun way? Become one of the first and receive a special discount!