![](https://csdnimg.cn/release/download_crawler_static/9700029/bg12.jpg)
xxi Introduction
Chapters 2
Chapters Two and Three, are somewhat external to Swift 3. I included them because they
are important topics. We should know what features are available to use in our IDE, Xcode.
We will examine previous features in Xcode such as the UI Debugger and Code Coverage as
well as the brand new Xcode Source Editor Extensions. Given that we can now extend our
IDE, this opens the door for a much better development experience. I know I am going to
enjoy all the emojification extensions and making life harder on my coworkers. Chapter Two
will also discuss the Address Sanitizer, Thread Sanitizer, and the Memory Graph Debugger.
The Memory Graph Debugger is a very powerful tool and I am really looking forward to using
it in Xcode 8.
Chapter 3
Chapter Three explains the idea of Swift modules. Swift modules include our apps and
dynamic frameworks. Dynamic frameworks make creating third party libraries super easy,
which just makes them more important to understand as more can show up our projects. We
will also touch on some package managers available, such as Cocoapods, Carthage, and
the official Swift Package Manager.
The official Swift Package Manager is where I am very hopeful. The more widely adopted
this package manager becomes, the greater the potential for Swift to run anywhere.
Since Swift was open sourced, I have been very hopeful to see it pop up in other areas of
development, such as game development. The Swift Package Manager and Swift being
open source make this a possibility. In Chapter Three we are going to build a basic package
of our own.
Chapters 4
Chapter Four is all about architecture. We will examine several design patterns including
MVC, MVVM, Presenter, and Dependency Injection. Design patterns are key to software
development in general. Everything has its own flavor and iOS is no different. We will only
briefly touch on MVC, the main design pattern in iOS. The two main patterns we will go
into detail about are MVVM and Dependency Injection. These are the two main patterns we
are going to use when building our app in Section II. Chapter Four will also discuss Anti-
Patterns. Design Patterns can make our code extensible and allow it to scale. Anti-Patterns
are the opposite. We will examine how certain Anti-Patterns can ruin our code bases and
how to avoid them. Chapter Four will then feed directly into Chapter 5 , Protocol Oriented
Programming.
Chapter 5
Protocol Oriented Programming (POP) is a really awesome topic. It can solve a lot of
different problems, but it requires a slightly different way of thinking. Chapter Five is going to
prepare us to use POP in Section II and our app. POP was introduced in Swift 2 and we will
touch on it in Chapter One when discussing the evolution. POP can describe architecture,
which is why Chapter Four is so important, but more on that later. Understanding how to
effectively use POP can also avoid Anti-Patterns.