Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Mastering macOS Programming
  • Toc
  • feedback
Mastering macOS Programming

Mastering macOS Programming

By : Gregory Casamento, Stuart Grimshaw
3.2 (6)
close
Mastering macOS Programming

Mastering macOS Programming

3.2 (6)
By: Gregory Casamento, Stuart Grimshaw

Overview of this book

macOS continues to lead the way in desktop operating systems, with its tight integration across the Apple ecosystem of platforms and devices. With this book, you will get an in-depth knowledge of working on macOS, enabling you to unleash the full potential of the latest version using Swift 3 to build applications. This book will help you broaden your horizons by taking your programming skills to next level. The initial chapters will show you all about the environment that surrounds a developer at the start of a project. It introduces you to the new features that Swift 3 and Xcode 8 offers and also covers the common design patterns that you need to know for planning anything more than trivial projects. You will then learn the advanced Swift programming concepts, including memory management, generics, protocol orientated and functional programming and with this knowledge you will be able to tackle the next several chapters that deal with Apple’s own Cocoa frameworks. It also covers AppKit, Foundation, and Core Data in detail which is a part of the Cocoa umbrella framework. The rest of the book will cover the challenges posed by asynchronous programming, error handling, debugging, and many other areas that are an indispensable part of producing software in a professional environment. By the end of this book, you will be well acquainted with Swift, Cocoa, and AppKit, as well as a plethora of other essential tools, and you will be ready to tackle much more complex and advanced software projects.
Table of Contents (21 chapters)
close
close
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Free Chapter
1
Hello macOS
Hello macOS
It's going to be Swift
And more than Swift
It's going to be Xcode and more
The book's overall structure
The serious developer's toolkit
What you'll get from this book
Summary
2
Basic Swift
Basic Swift
Variables and types
Comments
Arrays, dictionaries, and sets
Value and reference types
Operators
Structs, classes, and other data structures
Enumerations
Optionals
Control flow
Functions
Summary
3
Checking Out the Power of Xcode
Checking Out the Power of Xcode
A quick and simple sketch app
Speeding it up with code snippets
Logging with special literals
Getting the most out of breakpoints
Behaviors
Understanding schemes
Why build configs are so cool
Summary
4
MVC and Other Design Patterns
MVC and Other Design Patterns
Programming paradigms
Encapsulation
A path through the forest
Summary
5
Advanced Swift
chevron up
Advanced Swift
Control flow
Functions
Enumerations as data structures
Protocols
Customizing operators
Collection types
Optionals
Summary
6
Cocoa Frameworks - The Backbone of Your Apps
Cocoa Frameworks - The Backbone of Your Apps
Understanding Foundation Kit
Import statements
Leveraging key-value observing
Cocoa bindings
Summary
7
Creating Views Programmatically
Creating Views Programmatically
Why code instead of IB?
Setting our goals
Coding a table view
Observing without bindings
Adding further control elements in code
Summary
8
Strings and Text
Strings and Text
Strings and characters
NSTextView
Summary
9
Getting More from Interface Builder
Getting More from Interface Builder
Advanced IB navigation
Debug View Hierarchy
Encapsulating views with NSStackView
Taming the storyboard
Summary
10
Drawing on the Strength of Core Graphics
Drawing on the Strength of Core Graphics
Why not use an image?
Why not use native views?
Creating custom views
Custom buttons
Dial clock
Pie clock
Summary
11
Core Animation
Core Animation
What is Core Animation?
Introducing CALayer
Animating CALayer objects
Animating NSViews
Summary
12
Handling Errors Gracefully
Handling Errors Gracefully
Errors aren't mistakes
Expecting the unexpected
Swift error handling
NSError handling
Summary
13
Persistent Storage
Persistent Storage
Creating a project
Using UserDefaults
Saving text to the Documents folder
NSCoding/NSKeyedArchiver
Presenting open and save dialog boxes
Summary
14
The Benefits of Core Data
The Benefits of Core Data
What Core Data is, and isn't
Core Data, Cocoa Bindings, and no code
Using our data model
More about Core Data
Summary
15
Connect to the World - Networking
Connect to the World - Networking
Patterns for downloading data
Downloading using closures
Downloading using a URLSession delegate
No third-party frameworks?
The URLSession framework
Cache rewards
Summary
16
Concurrency and Asynchronous Programming
Concurrency and Asynchronous Programming
Concurrency and asynchronicity
Summary
17
Understanding Xcodes Debugging Tools
Understanding Xcodes Debugging Tools
Checking out Xcode's debugging tools
Leveraging breakpoints
Summary
18
LLDB and the Command Line
LLDB and the Command Line
LLDB
Summary
19
Deploying Third - Party Code
Deploying Third - Party Code
Common use cases
Distribution methods
Pros and cons
Different installation methods
Other package managers
The price of complexity
Summary
20
Wrapping It Up
Wrapping It Up
App distribution
Summary
And finally

Customizing operators

In addition to the operators provided by the Swift language, we can both override existing operators and, where necessary, create new ones.

Adding operator implementations to types

This sounds so complicated, but it is, in fact, really easy. All we need to do is define an implementation of any given operator for any given type.

Note

For the time being, we'll use a custom type, although what we are doing can be used equally effectively for Swift and Cocoa types.

We'll start by defining a custom type:

struct GridMovement 
{ 
  let rows: Int 
  let cols: Int 
}

Now that we have it, we notice that it would make perfect sense to be able to apply some basic arithmetical operators to our type. We could add these to the main type declaration, but convention (young though it is) suggests we put it in an extension:

extension GridMovement 
{ 
  static func + (lhs: GridMovement, 
                 rhs: GridMovement) -> GridMovement 
  { 
    let rows = lhs.rows + rhs.rows 
    let cols...
End of Section 7
Next Section
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete