Almost 25 years ago before I went down the rabbit hole of backend programming - I did some windows app development. I want to get into macOS programming now (I have been using a mac for the past 5 years and want to get to a place where I can build some hobby apps - I don't need to make money - I just need the damn machine to do what I want it to) - but I am having difficulty figuring out the right resources.<p>I am not interested in API documentation or how-to recipes. I am looking for explanations that will help me build a conceptual understanding of macos UI development. What is the equivalent of the event loop under macos? Do events bubble up through the hierarchy? What is the right way to persist user configuration?<p>In the windows era there was a very famous book called "Programming Windows" by Charles Petzold. I am hoping that I can find similar book for macOS programming.<p>Please do point me to the resources that have helped you.<p>I am not interested in non-native frameworks like Electron or PyQt. If I am developing an app for myself I don't want to deal with daily irritation of working with a non native framework.
I would suggest <i>Cocoa Programming for Mac OS X</i>, even though it's based on Objective-C and the book is old. That means it's based upon older versions of Xcode and Mac OS (like ~10 years old). Conceptually it's a good book, but because of it's age the code examples, etc are outdated. The publisher does have forums which can be helpful:<p><a href="https://forums.bignerdranch.com/c/cocoa-programming-for-os-x-5th-edition/9" rel="nofollow">https://forums.bignerdranch.com/c/cocoa-programming-for-os-x...</a><p>They also have a Swift book, but I haven't personally read it. They also have an Advanced Mac OS X book, but it's also old and isn't on their website anymore.<p><a href="https://bignerdranch.com/books/" rel="nofollow">https://bignerdranch.com/books/</a>
"I am looking for explanations that will help me build a conceptual understanding of macos UI development."<p>it depends on your learning style of course, but if you like lecture / course-style learning, i highly recommend paul hegarty's CS193P, it will definitely give you the in-depth, conceptual explanations you're describing.<p>while it is an iOS dev course (taught at stanford, lectures are freely offered online), the newest lectures are using swiftUI for UI, so pretty much all of it will translate to doing macOS dev.<p>paul is a cs prof at stanford and worked at NeXT and then on the objc lang many, many years ago, so he's been doing this a while and knows a thing or two :)<p><a href="https://cs193p.sites.stanford.edu/" rel="nofollow">https://cs193p.sites.stanford.edu/</a>
I had great luck with the Big Nerd Ranch books[0].<p>I’m not sure that I can recommend starting with SwiftUI, yet. The tech is still quite green, and quite different from AppKit (the current MacOS framework). The documentation also … <i>leaves something to be desired</i> …<p>But it also depends on how soon you want to be <i>shipping</i> software.<p>It might be a great idea to start with SwiftUI, if you think you’re still a couple of years from releasing stuff. I’m sure it will mature rapidly.<p>Of course, you could also learn a cross-platform system, like Electron, or React Native. I can’t make any suggestions, there.<p><i>Source: Been shipping native Mac software for over 30 years.</i><p>[0] <a href="https://bignerdranch.com/books/" rel="nofollow">https://bignerdranch.com/books/</a>
If you're not writing command line programs (99% of what I do) I suggest adopting SwiftUI for your interface.<p>It's Apple's future for cross platform (ios/macos/watch) applications. Hardcore longtime mac devs find it frustratingly unable to do some complex things they want to do (and yay that they do!) to take advantage of the mac OS. But you don't want that; you just want to interact with your own code. And SwiftUI will let you do the basic stuff easily...and likely just (well, almost just) recompile your program for your iphone or ipad.
<i>Just do it.</i><p>I started with one of the Big Nerd Ranch books many years ago. I spent a few evenings reading it, and then spent a few hours dabbling with Objective C in XCode. I then got frustrated and put it down for a few years until I took a job that involved some Objective C. (This was over a decade ago.)<p>It's surprisingly easy to learn the details of system calls by Googling and looking at stack overflow. Yes, the semantics are different, but the general theory is the same. There's a main thread that's often referred to as the main run loop. Accessing your UI outside of the main run loop (thread) is a big no-no.<p>As much as I want to vouch for learning Swift, (it's really easy if you have a Java / C# background,) there's also a good reason to be proficient in Objective C: It's just a layer on top of C. It's very easy to wrap C APIs in Objective C and then call them from Swift. This is important, because if you're trying to do something low-level, you will need to interact with a C API. (Although, Swift fixes a lot of the weirdness of Objective C if all you want is something that's like Java / C#.)<p>FWIW: There are some semantic differences that can take some time to adjust to. In Objective C, sending a message to a null object is a no-op instead of a runtime exception. Swift appears memory safe, but I've done things with timers that cause surprise crashes.
I assume those questions are rhetorical, but let me try to answer them in a very terse form just so you have some terms to search the docs for. Assuming you want to use AppKit.<p>> What is the equivalent of the event loop under macos?<p>NSRunLoop / CFRunLoop. You rarely need to interact with it directly. Typically only the main run loop on the main thread is important, if you want to do something on a different thread you typically use dispatch queues (GCD=grand central dispatch) instead of run loops.<p>> Do events bubble up through the hierarchy?<p>Yes, most events go up the responder chain, which is typically view -> superviews -> window -> app. You typically respond to events by implementing methods defined in a protocol (like "keyDown" or "insertTab") or by implementing delegate methods ("windowWillClose"). Sometimes you also have to listen for notifications from NotificationCenter.<p>> What is the right way to persist user configuration?<p>NSUserDefaults for everything that can be serialised into a number/string/dictionary easily, and the application support directory for anything you want to store in files.
Paul Hudson has a decent book on macOS programming using SwiftUI and AppKit. It isn't perfect but it is a decent place to start <a href="https://www.hackingwithswift.com/store/hacking-with-macos" rel="nofollow">https://www.hackingwithswift.com/store/hacking-with-macos</a>
Here’s a tutorial from Apple on creating a Mac app with the latest declarative framework: <a href="https://developer.apple.com/tutorials/swiftui/creating-a-macos-app" rel="nofollow">https://developer.apple.com/tutorials/swiftui/creating-a-mac...</a>.
One thing to decide maybe before specific books is if you want to do SwiftUI programming or more traditional Cocoa programming. They both have advantages, and they can be mixed, but if you are just learning probably best to focus on one approach to start.<p>SwiftUI is new future according to Apple, easy to start, but also unpolished compared to Cocoa. Cocoa is old and polished, but maybe eventually a legacy technology. I'm personally still in Cocoa world, but parts of SwiftUI are interesting.
I recently did the SwiftUI tutorials that had a chapter on macOS (from the context of adding macOS as a target alongside iOS). <a href="https://developer.apple.com/tutorials/swiftui" rel="nofollow">https://developer.apple.com/tutorials/swiftui</a><p>I expect SwiftUI to stay pretty high-level so don’t expect nitty gritty details. But Apple seems to be putting a lot of effort there so you might want to check it out.
Apple's Own Developer Documentation is Exceptional ranging from Cookbook-style guides to Reference Documentation.<p><a href="https://developer.apple.com/documentation/technologies" rel="nofollow">https://developer.apple.com/documentation/technologies</a><p>There are dozens of entrypoints depending on the framework (e.g. SwiftUI, Cocoa, CoreFoundation etc. ) , Platform & Application you are interested in .<p>I recommend starting with an application in mind (e.g. a MenuBar Utility, Notification Bar Widget, Standalone App, CLI utility, etc) and then digging through Apple's own framework documentation .<p>That will give you the e2e experience covering all the tools & frameworks needed to finish the task. Then repeat with a more complicated app or one in a different domain.
In a past life I spent a lot of time developing for iOS, and the one incredibly sore spots in terms of documentation was the build process. Particularly, what are all the things I need to know to effectively build my app, and debug the process.<p>The Apple-provided documentation assumes you already know many of the ins and outs of C/C++ build arcana, and on top of that does a terrible job of explaining what parts XCode adds or subtracts to the process. I never came across a resource for this information that was even passable, and wound up getting most of my answers from IRC.
To get started, I'd Protocol Oriented Programming from WWDC. Not a tutorial or how-to, but more of a look into the philosophy behind Swift.<p><a href="https://developer.apple.com/videos/play/wwdc2015/408/" rel="nofollow">https://developer.apple.com/videos/play/wwdc2015/408/</a>
I recommend starting with 100 days of SwiftUI. <a href="https://www.hackingwithswift.com/100/swiftui" rel="nofollow">https://www.hackingwithswift.com/100/swiftui</a><p>Despite the name, it’s quite fast to get through.<p>Apple also has really great videos on life cycles etc <a href="https://developer.apple.com/wwdc21/10022" rel="nofollow">https://developer.apple.com/wwdc21/10022</a> that go over the underpinnings
This might not be a popular opinion but it was what worked for me:
- Research a little about PostScript and the display version.
- NextStep Developer Documentation [1]
- Apple older documentation (it is archived, but covered a lot of stuff)<p>Why this instead of a book? MacOS X UI is the result of many years of experiment and technologies. Going over the historical view gave me time to build a mental framework to work on instead of pushing things as they are today. MacOS is also changing so much that the documentation gap only gets worse with time.<p>Storyboards, SwiftUI, iOS, UIKit are noisy in that sense because they solve problems that you might not understand from the get go.<p>Understanding Objective-C is also crucial because besides SwiftUI, the backbone was made with Objective-C characteristics in mind. But this one I don’t have good references for besides Smalltalk books and Clang documentation.<p>[1] <a href="http://www.nextcomputers.org/NeXTfiles/Docs/NeXTStep/3.3/nd/" rel="nofollow">http://www.nextcomputers.org/NeXTfiles/Docs/NeXTStep/3.3/nd/</a>
Do a little iOS dev since that has 100x more learning resources.<p>Once you grok iOS, you'll be at home with macOS since they follow the same patterns.<p>Stick with storyboards, don't bother with SwiftUI (no, really, don't do it) and try to use as much default out of the box behaviour as possible, instead of wondering 'how do I do that X thing I did on platform Y'.
A couple years ago I wrote a blog post "Resources for learning Objective-C and AppKit". I wouldn't say it's comprehensive, but it may be useful. <a href="https://lapcatsoftware.com/articles/learning.html" rel="nofollow">https://lapcatsoftware.com/articles/learning.html</a>
Apple Developer Documentation Archive. <a href="https://developer.apple.com/library/archive/navigation/" rel="nofollow">https://developer.apple.com/library/archive/navigation/</a><p>It's filled with the specific type of knowledge you're looking for.
Highly recommend beginning with Swift and using SwiftUI for UI development. Dive into AppKit and Obj-C when (if) necessary. As an additional companion, check out the HIG [1] or Human Interface Guidelines. It's a great starting point for introducing a feature "the Apple way", and it'll make knowing what to reach for in SwiftUI much more straight forward.<p>[1] <a href="https://developer.apple.com/design/human-interface-guidelines/guidelines/overview" rel="nofollow">https://developer.apple.com/design/human-interface-guideline...</a>
I'm just finshing up my first macOS app. I went with SwiftUI because I was new and didn't want to learn an "old" tech. The reality is outside of very basic stuff, SwiftUI is not capable of doing a lot of stuff, so I ended up have to learn not only AppKit as well, but how to fuse AppKit into SwiftUI and fuse SwiftUI into AppKit.<p>My advice is don't be attracted by the shiny toy that is SwiftUI. It's a steaming pile to dung, unless you just want some basic forms/tables/text.
Started a new app last year using Stotyboards and AppKit and haven’t regretted it for a second. I use SwiftUI on iOS devices on a daily basis and I don’t have to dip into UIKit very often anymore, but AppKit on macOS was always more mature than UIKit let alone SwiftUI. Plus SwiftUI still has rough spots on macOS.<p>If you want to go for the typical macOS look & feel stick with AppKit.<p>Resources: barely any<p>Apparently you’re either not interested in macOS development or you’re way too experienced to need help.
The other responses have some great answers, but I learn best by breaking something that is already working, and so this list may have useful sources of code to poke around in: <a href="https://github.com/serhii-londar/open-source-mac-os-apps">https://github.com/serhii-londar/open-source-mac-os-apps</a>
Be aware any application you distribute must be signed now, or gatekeeper will not allow it to run. This means you must pay the $100 yearly apple developer fee, apple wants to make sure you're not economically disadvantaged. There are no exceptions even for students or open source. Only a licensed nonprofit may be able to waive it.
Apple has tons of videos on their developer portal.
<a href="https://developer.apple.com/videos/all-videos/" rel="nofollow">https://developer.apple.com/videos/all-videos/</a><p>Usually a good primer for any topic you want to dive into.
There is a lot of excellent documentation on Apple's website, but it's all in the “documentation archive” and is at least five years out of date. Please read it anyway! There's great conceptual introductions to every topic you could imagine in there.
I found this course with great ratings while browsing on Udemy this weekend:<p><a href="https://www.udemy.com/course/professional-macos-programming/" rel="nofollow">https://www.udemy.com/course/professional-macos-programming/</a>
Building macOS apps is a lot easier with SwiftUI now. This book has quite a few good examples - <a href="https://www.amazon.com/dp/B0BP5P9H31" rel="nofollow">https://www.amazon.com/dp/B0BP5P9H31</a>
I found the books about Apple technologies by this collective to be very good: <a href="https://www.objc.io/" rel="nofollow">https://www.objc.io/</a>
I found Paul Hudson's "Hacking with Swift" products quite useful.<p><a href="https://www.hackingwithswift.com" rel="nofollow">https://www.hackingwithswift.com</a>
The most bang for your buck is to watch the latest WWDC videos. Use SwiftUI to hit the road and fill the gaps later. Declarative UI is too powerful and removes a lot of the excuses people had before in UI development. There’s different technologies you’re going to encounter that are the same as Windows-land, but has the Apple branding.
shamelessly off-topic but if anyone here is already good at Objective-C development for macOS and looking for remote work, please drop us a line at: jobs@corecode.io