Swift High Performance: Leverage Swift and enhance your code to take your applications to the next level

lots of tips for intermediate Swift programmers. This is my second Swift Language book after the excellent "Swift Programming" by Big Nerd Ranch.

Very helpful book. Filled in the gaps to swift ideals that are only glossed over in other books. You do need some exposure to swift to get the most from it, but still a good reference for beginners as well as seasoned swift converts.

This book does a good job of covering the concepts that affect application performance. These concepts could be applied to other programming languages as well. Coverage of the Swift Toolkit is invaluable. This is a must have book if you want to take your coding from beginning or intermediate to advanced. Even advanced programmers would find it valuable as a reference.

I was looking for a heavyweight Swift book as I felt the other books either covered the same ground or otherwise seemed to be the same as Apple's own documentation; and having built apps with Objective C I didn't want a book that covered Xcode, making views, etc; I feel that this book is the heavyweight Swift book I was looking for.The book is quite portable and isn't a big chunky book. I would say it is designed for more middleweight developers who want to learn Swift but also want to cover more aggressive/heavy topics.Although starting on simple concepts, the book wastes no time getting to subjects and ideas that are, for me at least, a bit heavyweight (as I am new to Swift).It covers boosting Swift performance, best practices, mixing Objective C and Swift and other concepts.Some subjects are glossed over, but on the whole I like the book and will continue to read it and re-read it.There are some spelling errors; and there is one or two examples where an example has you confused until you turn the page where it details it further.

The intent of the book is to provide its readers with ways to make their code more “Swift-like” (for example, more functional in its style) and more efficient. There are almost no books that do so at this point in Swift’s development. In fact, most Swift books are at the introductory level. “Functional Programming in Swift” by Chris Eidhof, Florian Kugler and Wouter Swierstra covers more advanced features, but it is written with a background in mathematics in mind, as are many books on functional programming. Likewise, “Advanced Swift” by Chris Eidhof and Airspeed Velocity, as its name implies, is at a more advanced level. Each of these books is valuable, but SwiftHigh Performance fills a gap by attempting to cover advanced features while remaining more approachable for the beginning to intermediate programmer.One flaw in the book is that in the first two chapters on Swift’s power and how to create a proper Swift app architecture, a lot of material is covered in very terse manner, with no discussion of how they impact performance — which is the purpose of the book. Worse yet, Swift’s features are simply listed and concepts mentioned without explanation in most cases. A prime example of this is the coverage of Swift’s functional language and standard library features in Chapter 2. All of this can be learned more easily and in more detail in Apple’s Swift book. In my opinion, this makes these first two chapters completely disposable. It is not until Chapter 3 (after one third of the book) thatperformance issues in Swift are first covered.Some of the source code exhibits minor glitches with the latest version of Swift on Xcode 7.2 that are not fixed by automatic conversion to the latest Swift syntax. These are inconveniences rather than show-stopping bugs. For example, the Set.swift file in the Data Structures project calls advance(), not advanceBy(). More puzzling is that numerous empty print() calls are left throughout the code. Why use print if no message is to be displayed?There are several grammatical, syntax and spelling mistakes that bypassed the editors. I won’t mention them all, but three can be found almost immediately: (1) In the sample program demonstrating tuples in Chapter 1, a string of “not fount” is used twice. (2) Computer scientist Donald Knuth’s name is misspelled. (3) An “@IBOutles” is mentioned in Chapter 2. These errors could have been easily corrected by an editor or reviews prior to publication, but I’ve also noted the same problem of a large number of spelling and grammatical errors — including very awkward sentence syntax that made reading difficult — in another recent Packt book. The publisher needs to devote more time and effort in polishing the released books.Despite these shortcomings, I still recommend buying this book. It is in Chapters 3-7 where this book truly shines, starting with a discussion of running the REPL within Xcode, which I would not have thought of on my own. It covers ways of improving the performance of swift code, with some sample code’s generated assembly code and performance displayed. A lot of valuable information is contained in these chapters that makes reading “Swift High Performance” worthwhile.Specific Comments:Chapter 1- Exploring Swift’s Power and Performance-Chapter 1 is simply an overview of the features of Swift. Most of these features are given only a cursory mention. This chapter is therefore not really necessary, as readers of the book would be people who are already programming in Swift and want to improve the quality of their code. This chapter could have been almost entirely omitted, with perhaps a few points merged into the following chapters.In the Clean Code Summary, the sample program should be finding people in the array of Persons who below the age of 18, then lower-case their names. In fact, the program finds people below the age of 18, then lower-cases the names of everybody in the original array, not just those below age 18. This is true of both the Swift and Objective- C versions of the code.Terms are presented without defining them. For example, in the discussion on functional programming, the term “first class function” is mentioned but not described. In the Generic Purpose section, the function minimum is made generic, but reason for the need to make the generic conform to the Comparable protocol is not mentioned.The section on Objective-C interoperability should have expanded slightly on its coverage of upcasting and downcasting, and why there are differences between them. Specifically, it is first stated that casting is usually an unsafe operation, yet the sample code suggests that is it only downcasting that is unsafe. In addition, which Objective-C types have toll-free bridging that removes the need to typecast?The coverage of optionals as a way to avoid the Pyramid of Doom problem should be combined with the coverage of optionals in Chapter 2.Chapter 2- Making a Good Application Architecture in Swift-In the beginning of the section on functional programming, it’s stated that a function should only operate with arguments passed to it. Perhaps this should be rephrased to state that it should operate only on arguments passed to it and not class properties or global variables.It’s stated that functional programming describes what you want to do and not how you want to do it, but this statement is not explained. I realize that this is not a book on functional programming, but if a concept is mentioned, it should also be explained. This is a general problem throughout this chapter.Chapter 3- Testing and Identifying Slow Code with the Swift Toolkit-The coverage of REPL is only two pages. While this is probably adequate for Apple programmers, who will more likely use the playground instead, a future edition of the book might need to cover it in more depth because the open-source version of Swift for Linux does not include playgrounds. A good resource for using playgrounds is Erica Sadun’s book “Playground Secrets and Power Tips”. Likewise, a complete reference on creating interactive documentation for playgrounds is Erica Sadun’s “Swift Documentation Markup: an Illustrated Tour”.In the discussion of the LLDB debugger, it’s stated that “because we made an iOS app”, a breakpoint will be made in the didFinishLaunchingWithOptions method. I could not find where this iOS app is discussed.The coverage of running the REPL within Xcode, and doing performance logging with console logs is very good.One section that I fould a bit puzzling is the section comparing the performance of variables (declared with var) versus constants (declared with let), It looks like the code using variables and the code using constants perform the same! Average time for constants = 12.681316, and for variables = 12.681316. I assume this was a cut-and-paste error by the author.Chapter 4- Improving Code Performance-The section on functions and methods is very useful. It directly compares the speed of function calls at different scopes in the program, such as calling global functions, static methods, final methods and instance methods.The section on removing print logs has some excellent tips, as does the coverage of using the final keyword for functions.The direct comparison of generated assembly code for value objects (structs in this case) and reference objects (classes) clearly demonstrates the ability of Clang to optimize code for value objects.Chapter 5- Choosing the Correct Data Structure-The Collection Memory Allocation section starts by mentioning performance optimization of collections “when you instance and instance of it”. That should probably say “instantiate” instead.Chapter 6- Architecting Applications for High Performance-This chapter discusses concurrency by initially stating the duties of the main thread. It might help some readers if thread was defined and discussed first.The Threads section shows sample code calling the NSThread.detachNewThreadSelector method, but the method is not really discussedaside from stating that it can create a new thread. What are the advantages or disadvantages of using it versus using another way to create a new thread?In the first paragraph of Designing Asynchronous Code, it’s stated that the technique just taught will “get more function style Input -> Output functions style”. I assume the author means that the code’s style adheres to a functional programming style better.Chapter 7- The Importance of Being Lazy-Very nice coverage of lazy loading and lazy sequences and collections.Chapter 8- Discovering All the Underlying Swift Power-This chapter mentions many tools, but really offers little insight into how to use them to analyze core or to find performance bottlenecks or improper memory usage.In the coverage of the Hopper Disassembler, it’s stated that we’ll compare optimized and unoptimized code, but I could not find the results of the compilation. Where is the code compared? This appears to be missing.