Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

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

Customer Reviews

4.7 (3)

5 star

66.7%

4 star

33.3%

3 star

0

2 star

0

1 star

0

A brief history of reference counting

Before we get into the details of ARC, we need to rewind the time machine to a previous epoch. The year is 1988, and Objective-C is licensed by NeXT and starting to make its way into their operating system. In 1996, Apple acquires NeXT, alongside the release of OS X, a new and modern toolchain based on Objective-C. Objective-C is a strict superset of C, which means that any valid C code is valid Objective-C code, but unlike C, Objective-C has a modern and efficient memory management engine, based on reference counting.

Reference counting is a technique that accounts for the exact number of references to a particular object that exist at any given time in the memory. Once there are no references, an object, it is deallocated. This is a very different memory management technique, as compared to garbage collection, which you can find in Java...

Search

Your notes and bookmarks