migrating an application from carbon to cocoa

Question

I am working on an application in which I need to migrate the whole code of it from carbon to cocoa.I have experience in programming of C,C++,python and Java during my college time and internship but have never touched objective C or have done any programming for Mac(Carbon and Cocoa) before this.

So Can you please suggest me some sources to start with, also how should I go about the whole migration ?

After researching on net I have found that most the people have suggested following books

Cocoa Programming for Mac® OS X, Third Edition by Aaron Hillegass

Programming in Objective C - Stephen Kochan

I have got both these books.

Should I read them first and then should start with the code change? (it will take some time to read both of these)

OR

after having a decent fimiliarity with Obj C and Cocoa, should I directly get started with code migration?

Also,

since I don't know carbon , what should I refer to learn carbon to have sufficient knowledge to migrate the carbon code to cocoa?

Answer 1

First, learn Carbon so you can read the program and understand how it's currently implemented.

Install the Legacy documentation set in Xcode to gain access to the Carbon guides. You'll want to read the Carbon Overview , then Getting Started with Carbon , then everything that Getting Started links to. You'll also need to learn Core Foundation, which some of the more modern parts of Carbon use; read Core Foundation Design Concepts and the Memory Management Programming Guide for Core Foundation .

Then, learn Cocoa.

I didn't learn by the Hillegass book, but a lot of people swear by it. My current favorite Cocoa book is “Cocoa and Objective-C: Up and Running” by Scott Stevenson . The way I learned Cocoa was using Apple's own docs. Start with The Objective-C Programming Language , the Cocoa Fundamentals Guide , and the Memory Management Programming Guide for Cocoa . Much of the last document will seem really familiar, but skip nothing. Read every one of those guides from beginning to end and all the way through.

Once you've learned Cocoa's general concepts, you can move on to more application-specific material. Start with the Application Architecture Overview and most of what that document links to. The Cocoa Guides list has the full list of guides.

Down the road, you'll also need to make the application compatible with 64-bit mode. If you still have any Carbon code by that point, you'll need to read the 64-bit Guide for Carbon Developers ; either way, you'll also need the general 64-bit Transition Guide and the 64-bit Transition Guide for Cocoa .

Answer 2

I am working on this process myself right now, and it's a fairly complex undertaking for a full document-based application that uses a few frameworks. My Carbon app has dozens of menu items, the interface is built with Carbon Nibs and implemented using Carbon event hooks. The programming language is C++. Going back in history, the original Mac classic version was implemented in straight C, so there's a little bit of legacy from that era too. Resource-based PICS for example!

There are several approaches one can take, so it depends on your particular situation how to proceed. In my case I decided to start with a bare Cocoa document-based project and start building the document loading code, because the hooks for that are already in place in the empty project. This seems like a good place to start for me, because it gets me into the mode of working with Cocoa and thinking about the app in terms of smaller pieces.

You really have to take a methodical approach and look at what your app depends on in Carbon versus which parts of your app are independent - for instance your abstract classes. If your app is in C++ there may be some pitfalls with converting over to pure Objective-C. Operator overrides can be tricky to notice, for example.

You can mix C++ with Objective-C, as described in Apple's Carbon-Cocoa Integration Guide and around the web you can find plenty of C++ wrappers for Cocoa foundation objects like NSStrings . So if you already have C++ classes that wrap CFString, these can come in handy.

Generally-speaking, you can leave your data storage just as it is. If you use malloc() and calloc() to make a linked list of structs, there's no special reason to move over to an NSArray. You won't get better performance. The real change comes in the interfaces, the way you call and access that data from other objects. If you decide to mix C++ and Objective-C objects in the same app it helps to encapsulate as much as possible. That is, as much as possible make your abstract C++ classes only refer to their own data and that of other C++ objects. Eventually this will make it easier to transition them to Objective-C.

If you're transitioning from one event model to another or from Carbon port-based imaging to Cocoa's views-based imaging, it's probably best to start with a fresh Objective-C app and bring over your model classes first. Add some test functions to make sure they all work within the new language. If your app is anything like mine (old) then it probably needs to display some things larger, and to have more polish in the interface. This is a good time to rebuild those parts piece-by-piece.

There's definitely no great shortcut. The PDF linked above is the best document I've found on the topic.