Book Image

Swift High Performance

By : Kostiantyn Koval
Book Image

Swift High Performance

By: Kostiantyn Koval

Overview of this book

Swift is one of the most popular and powerful programming languages for building iOS and Mac OS applications, and continues to evolve with new features and capabilities. Swift is considered a replacement to Objective-C and has performance advantages over Objective-C and Python. Swift adopts safe programming patterns and adds modern features to make programming easier, more flexible, and more fun. Develop Swift and discover best practices that allow you to build solid applications and optimize their performance. First, a few of performance characteristics of Swift will be explained. You will implement new tools available in Swift, including Playgrounds and REPL. These will improve your code efficiency, enable you to analyse Swift code, and enhance performance. Next, the importance of building solid applications using multithreading concurrency and multi-core device architecture is covered, before moving on to best practices and techniques that you should utilize when building high performance applications, such as concurrency and lazy-loading. Finally, you will explore the underlying structure of Swift further, and learn how to disassemble and compile Swift code.

Related Content you might be interested in

Current Title:

Small book image
Swift High Performance
Kostiantyn Koval
Nov, 2015 | 212 pages
No titles found
Table of Contents (15 chapters)
Swift High Performance
Swift High Performance
Credits
Credits
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Exploring Swift's Power and Performance
Exploring Swift's Power and Performance
Swift speed
Welcome to Swift
Swift's features and benefits
Swift interoperability
Performance – meaning and key metrics
Summary
2
Making a Good Application Architecture in Swift
Making a Good Application Architecture in Swift
Making a Swift application
The differences between variables and constants
Immutability
Value types and immutability
Representing the absence of values with optionals
Functional programming
Generics
Safety
Summary
3
Testing and Identifying Slow Code with the Swift Toolkit
Testing and Identifying Slow Code with the Swift Toolkit
REPL
Playgrounds
LLDB
REPL in Xcode
Console logs
Performance measuring in unit tests
Instruments
A reminder
Summary
4
Improving Code Performance
Improving Code Performance
Understanding performance optimization
Optimization checklist
Swift code compilation
Constants and variables
Method calls
Intelligent code
Improving speed
Value objects and reference objects
Swift arrays and unsafe C arrays
Avoiding Objective-C
Summary
5
Choosing the Correct Data Structure
Choosing the Correct Data Structure
An overview of data structures
Collection types
Swift standard library collections
Collection memory allocation
The CollectionType protocol methods
Accelerate and Surge
Other collections
Summary
6
Architecting Applications for High Performance
Architecting Applications for High Performance
Achieving high performance
Concurrency overview
Designing asynchronous code
Avoiding state
Divide and conquer
Controlling the lifetime
Summary
7
The Importance of Being Lazy
The Importance of Being Lazy
The lazy mindset
Lazy loading
Lazy collections and evaluation
Summary
8
Discovering All the Underlying Swift Power
Discovering All the Underlying Swift Power
How Swift is so fast
Swift command line tools
The Swift compiler
The Swift compilation process and swiftc
Analyzing executable files
Summary
Final thoughts
Index
Index

Controlling the lifetime

In our code, we have used an @autoclosure(escaping) attribute. It is a very powerful attribute and it deserves to be covered in detail. There is also an @noescape attribute. Let's explore them in more detail.

Applying the @autoclosure and @noescape attributes

First, let's have a look at when and how we could use these attributes. We can apply them to a function parameter with a function type. A function type can be represented as a method, function, or closure and it has (parameters) -> (return) notation. Here are a few examples:

func aFunc(f: () -> Void )
func increase(f: () -> Int ) -> Int
func multiply(f: (Int, Int) -> Int ) -> Int

@autoclosure

The @autoclosure attribute can be applied to a parameter with a function type that has no arguments and returns any type, () -> T. For example:

func check(@autoclosure condition: () -> Bool)
func increase(@autoclosure f: () -> Int ) -> Int

When we use an increase function without the @autoclosure...

Previous Section
End of Section 7
Next Section