Mastering macOS Programming.: Hands-on guide to macOS Sierra Application Development

In just a little over two years, Swift has become one of the software development world's most talked-about programming languages, and is even the most forked repository on GitHub (but then, how many new languages have the power of a multinational like Apple behind them?). The language has undergone (and is still undergoing) incredibly rapid evolution, guided principally by Chris Lattner and the team at Apple, but also by the wider community, since it was open-sourced in December 2015, with proposals for language changes by non-Apple developers being included in the release of version 3.0. This radical departure from Apple's usually secretive product development strategy has meant that Swift has already benefitted from the experience and perspective of a great number of developers of mixed backgrounds (in every sense), with Apple itself saying that release 3.0 contains work by a total of three hundred and sixty-odd contributors.

If you are coming to Swift from Objective C for the first time, you will find it a much more succinct and clear language, one that needs fewer lines of boilerplate code, not to mention fewer semicolons, than its predecessor. If your background is in Python, JavaScript, or Java (to name the obvious ones), you'll find the code much easier to understand at first glance than would have been the case with Objective C--this is a good time to add Apple's platforms to your portfolio.

But whether you refer to yourself as a software engineer, app developer, or hacker, there is substantially more to the job than writing Swift code inside Xcode. We will also be looking at interacting with bash shells in Terminal, dealing with files in XML format, data returned from the Web in JSON format, a little HTML, and the odd sprinkling of other languages, which may be used outside Xcode to good advantage.

We won't be going into a great amount of depth in these peripheral topics (if they can even be considered peripheral), but we will present what is essentially needed to get the job done, and give the reader an idea of the role they play in the larger picture. The interested reader will find no shortage of books and web resources with which to expand on the information presented here. There are also a number of articles available on the website that accompanies this book: http://grimshaw.de/macOS-book.

Much of this book, particularly the later chapters, will look at leveraging the considerable power of the Xcode-integrated development environment, in order to familiarize the reader with many aspects of development that go beyond code writing, to include debugging, performance measurement and improvement, working with source control within a team, and many others.

Software development is rarely a matter of using one single program, and we will be utilizing several tools other than Xcode to get the most out of the time we spend coding, compiling, and testing our work. You might be pleased to learn that none of these tools are going to cost you any money (although like any other tool, they come at the cost of a certain amount of time to be invested in order to reach a moderate level of proficiency). You might be even more pleased to learn that we will be covering this ground step by step, and no previous knowledge is assumed.

Broadly speaking, the book can be thought of as consisting of three parts:

The third part of the book will cover topics that concern any desktop application developer, but here they are dealt with in the context of programming Cocoa apps for macOS.

Some of these will seem more appealing than others. There are many topics in the early stages of learning to program that are (or perhaps just seem to be) less important and/or exciting, such as just writing a few pages full of code and hitting the Run button; but these things later become an essential and rewarding part of what we do as developers. As one moves from working on relatively small and simple projects, usually as a sole coder, to working on larger, more complex, and longer-term projects, frequently as part of a team of both devs and management staff, there is a profound change in priorities, as code clarity, code re-use, integration, documentation, and communication become major aspects of our work.

There are also fascinating challenges around dealing with some of the unpredictable aspects of software that needs to integrate itself successfully with a digital universe lying outside our app and beyond our control, particularly with regard to the Internet, as our code will need to deal robustly, efficiently, and gracefully with whatever comes back at it across the network.

Producing high-quality code, while working quickly and communicating effectively, is partly a matter of experience and partly a matter of knowing what tools are available to make the best use of the hours you spend coding, and which techniques to choose when designing the internal workings of your app.

These chapters will look at 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: on time, on budget, maintainable code. Which is basically what the industry needs from you.

And for which you will be handsomely paid. Just saying.

This brings us quite nicely to the goals of this book.

Well, in a general sense, its goal is to help you reach yours, of course. But how exactly are we going to do that?

The focus of this book is very much on real-world programming skills and best practices, with a clear preference for techniques that provide solid, maintainable code over a long app lifetime, as opposed to the latest Thing from the developer conferences. Similarly, we will concentrate more on the functional interior of the code rather than short-lived user-interface design trends that will be of little interest a year from now.

There is also a strong emphasis on developing the skills that a developer will need when working in the industry, within a team that may include other developers, including those working on different platforms, as well as graphic artists, technical leads, project and product managers, system administrators and back-end developers, and any number of other roles with which it is necessary to communicate with clarity and accuracy. These people will have their own corners of the business to attend to, to which you will frequently have to adapt your work, making it all the more important that you have a number of tools at your disposal to deal with rapidly changing requirements and priorities.

Frequently, it is necessary to include third-party frameworks and libraries, often ones that you would not choose yourself: maybe because the team has been using them within a project already; maybe because a client has requested the addition of an analytics engine to an app, or to add functionality to an app not available natively. These are perhaps the most common reasons, but they are not the only ones, and an ability to integrate these resources into your work is an essential part of modern app development, and one that is only likely to increase with time.

Professional coding means writing clear code, adhering where appropriate (which means most of the time) to established practices. We will prefer simplicity over cleverness every time, and hopefully this is a habit you will develop yourself.

A huge part of coding wisely means knowing which techniques to deploy, and which are better left out, in any given situation. It means learning to strike the right balance between clarity and the inevitable complexity that results from the growth of a project over time.

You will also learn to deal with version control safely, an essential part of working on larger projects, even as a sole developer.

Debugging your code is an essential part of programming, and we will look at the tools available to you in Xcode to make these tasks easier, faster, and safer. Fixing bugs can become a major part of your work, and your skills in this area will contribute greatly to your ability to deliver reliable code.

Finally, we will not shy away from references to resources beyond this book. The time is long gone when a developer can be expected to know every detail of a language or platform, and knowing where to search for documentation and help is an indispensable part of our work as developers. It has been said that a good developer spends two thirds of the time reading and one third coding. Although that should perhaps be taken with a pinch of salt, if only because it overlooks writing documentation, testing, and talking to clients, managers, and team members, it nevertheless makes clear that writing code is not only not everything, it's not even most of it.

Our highest priority is to impart knowledge that will be immediately and enduringly useful to you as a developer. That may seem like stating the obvious, but you will notice that the content of this book does not necessarily reflect the buzz and hype around the blogosphere's latest shiny new toys. It is true that even the oldest, best-tested tools were new once, but it is not our intention here to get lost in the esoteric delights of functional programming, protocol-oriented programming, reactive programming, or whatever else is the subject of heated debate at the time of writing.

That is not to say that such topics are somehow not thrilling, valuable, and thought-provoking. They most definitely are, but they are not within the scope of this book. However, the website is not limited in size, so we'll see what we can do.

Also not covered here is the migration and adaptation of Swift 2 code to Swift 3. There will doubtless be any number of articles out there covering this, but for the purposes of this book, we will treat Swift 3 as the only version of interest. And although it's an important topic, moving from Objective C to Swift is beyond the scope of this book.

Finally, we will not cover unit tests and integration testing. This field is a wide one, space here is limited, and the reader is encouraged to find resources that can do justice to both the topic itself, and the wide range of opinions surrounding it.

None of this is going to involve quantum leaps of comprehension. Assuming you understand the concepts summarized in the first few chapters (and we will make that assumption), this book will guide you, step by step, from a position of being able to code adequately to a position of being able to code well.

You will not only write better code, you'll write faster; you will be able to get across new frameworks more quickly; you'll soak up more of what you read on the Web and elsewhere; you'll be able to communicate your thoughts clearly to work colleagues and clients.

And I hope, very much, that you'll continue to feel that feeling of accomplishment you felt the first time you coded up Hello World in whatever language it was at the time. It's that spark that will enable you to code not only well, but brilliantly, if you stick with it.

The next chapter will provide a rapid-but-thorough review of the basics of the language's core features and syntax, assuming a basic familiarity with object-oriented programming, but no advanced knowledge of Swift's previous incarnations. So, without further ado, let us take a rapid tour of the basics of Swift 3.0.