Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Hands-On Design Patterns with Swift

By : Vilmart, Giordano Scalzo, De Simone

4.7 (3)

Hands-On Design Patterns with Swift

4.7 (3)

By: Vilmart, Giordano Scalzo, De Simone

Overview of this book

Swift keeps gaining traction not only amongst Apple developers but also as a server-side language. This book demonstrates how to apply design patterns and best practices in real-life situations, whether that's for new or already existing projects. You’ll begin with a quick refresher on Swift, the compiler, the standard library, and the foundation, followed by the Cocoa design patterns – the ones at the core of many cocoa libraries – to follow up with the creational, structural, and behavioral patterns as defined by the GoF. You'll get acquainted with application architecture, as well as the most popular architectural design patterns, such as MVC and MVVM, and learn to use them in the context of Swift. In addition, you’ll walk through dependency injection and functional reactive programming. Special emphasis will be given to techniques to handle concurrency, including callbacks, futures and promises, and reactive programming. These techniques will help you adopt a test-driven approach to your workflow in order to use Swift Package Manager and integrate the framework into the original code base, along with Unit and UI testing. By the end of the book, you'll be able to build applications that are scalable, faster, and easier to maintain.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Refreshing the Basics

Refreshing the Basics

Classes and structs

Enums

Closures, functions, and currying

Protocols

Tuples, type aliases, and generics

Summary

Understanding ARC and Memory Management

Understanding ARC and Memory Management

A brief history of reference counting

ARC – what is that?

Memory debugging

Leaks, cycles, and dangling references

Summary

Diving into Foundation and the Standard Library

Diving into Foundation and the Standard Library

Swift basic types

Container types

Mastering concurrency with Dispatch

HTTP with URLSession

Summary

Working with Objective-C in a Mixed Code Base

Working with Objective-C in a Mixed Code Base

Setting up your project

Nullability and optionals in Objective-C

Naming, renaming, and refining Objective-C for Swift

Lightweight generics in Objective-C

Cocoa design patterns in Swift

Summary

Creational Patterns

Creational Patterns

The singleton pattern

The factory method pattern

The abstract factory pattern

The builder pattern

The prototype pattern

Summary

Structural Patterns

Structural Patterns

The adapter pattern

The decorator pattern

The facade pattern and proxy pattern

The composite pattern

The bridge pattern

The flyweight pattern

Summary

Behavioral Patterns

Behavioral Patterns

The state pattern

The observer pattern

The memento pattern

The visitor pattern

The strategy pattern

Summary

Swift-Oriented Patterns

Swift-Oriented Patterns

Getting started with protocol-oriented programming

The type erasure pattern

Template pattern with protocol-oriented programming

Summary

Using the Model-View-Controller Pattern

Using the Model-View-Controller Pattern

A refresher on MVC

UIViewController

Composition and child view controllers

The model layer

Summary

Model-View-ViewModel in Swift

Model-View-ViewModel in Swift

Basics of the MVVM pattern

MVVM and data binding

Using Observables with ViewModels

Summary

Implementing Dependency Injection

Implementing Dependency Injection

Dependency Injection, a primer

Dependency Injection by example

Using a Dependency Injection Container

Summary

Futures, Promises, and Reactive Programming

Futures, Promises, and Reactive Programming

Callbacks and closures

Futures and promises

Reactive programming

Summary

Modularize Your Apps with Swift Package Manager

Modularize Your Apps with Swift Package Manager

Creating a library package

Adding third-party dependencies

Extracting and sharing a framework

Summary

Testing Your Code with Unit and UI Tests

Testing Your Code with Unit and UI Tests

Unit testing using XCTest

Advanced testing with mocks, spy, and others

UI testing with Xcode

Tips and tricks

Summary

Going Out in the Open (Source)

Going Out in the Open (Source)

Documenting Swift

Continuous integration

Using fastlane for automated delivery

Becoming a maintainer, tips and tricks

Summary

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Summary

In this final chapter, we covered one of the most important aspects of innovation in the software world: sharing your code with the world. While anyone can upload a few lines of Swift to GitHub, publishing a successful project is a particular art form. As of now, you should be able to use Jazzy to generate beautiful HTML documentation of your code. Using GitHub, Travis, or even GitLab to host and iterate on your project is now second nature. For your iOS apps, you are able to refactor complex shell scripts into simple actions with fastlane. Finally, your repository isn't naked with just code, but sports a useful README, a license, and you, as a fresh maintainer, are ready to deal with your first issues, merge and close your first pull requests, and pledge to respect and appreciate your users.

Reflecting on what we covered through this book, we started with the first...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Hands-On Design Patterns with Swift

Search

Your notes and bookmarks