This article explores some of the advantages and challenges faced by developers while migrating to Swift from Objective-C.
1. Do we want to migrate?
Before you start the migration process remove the old adage:
If it isn’t broken, don’t fix it!
Start by identifying the reasons why you wish to migrate. Here are some possible reasons why.
- The code is old and not updated for a very long time. You now wish to add new features.
- The frameworks/libraries you are using in your project have upgraded to modern Swift and no longer support your old Objective-C syntax. *You may still want to just update to modern Objective-C, but this would be a good time to jump onto swift.
- You see potential for improvement in code size/speed/performance by using new Swift features not available in Objective-C. For example: Generic Programming.
- The developers who developed the app in Objective-C have left and the new employees are proficient at Swift. *Again not a strong reason, but a valid reason if there is no other alternative. Asking people to sit down and learn Objective-C may not be practical, especially if they don’t have a background in C Programming.
- The app is due for a performance, stability, & bug fix update. This is a good time to consider migration to Swift.
Factors to keep in mind before considering migration.
- The cost of migration. This is the cost of keeping a certain number of developers occupied in migrating the code. The cost is in terms of time as well as money.
- Potential risks. Any change to the code increases the risk of bugs. The chances of introducing limits on backward compatibility also increase.
- Benefits gained. An assessment needs to be done as to whether there are any benefits of migrating to Swift. The Return on Investment needs to be figured out.
- Compatibility with 3rd Party or in house libraries that you might use.
After having thought through all this you are ready for the next step: “Prepare to Migrate”
2. Preparing to Migrate
This is where you actually begin to work on the migration of the App.
- As a first step perform a full code review of the app.
- The next step is a major decision. Should you rebuild your entire app from scratch or do a piece by piece migration. We will explore the advantages a little later in the article.
- Look for Swift versions of 3rd frameworks/libraries you use. This is not strictly required, however, this is a good time to check for new APIs.
- Identify parts of the project to migrate. This is to be done if it is a piecemeal migration. This marks you as ready for the next step: “Starting the Migration”.
3. Starting the Migration
Once you have everything in place you are ready to begin.
Migrations happen class by class. Select an Objective-C class to migrate and start working on converting it to Swift.
If you have any pure C functions then you can either choose to make them work with Swift or rewrite them in Swift.
While migrating pay special attention to your code. Here are some conversions that you can make.
- See if you can make it simpler by using Generic Programming instead of usingVoid *
- Replace the use of NSError * with exceptions.
- Use extensions to give types new capabilities.
- Consider creating your own Data structures. You may use Swift Arrays, Dictionaries if you wish. But this might be a good time to improve performance by building your own data structures.
- Embrace closures and protocols a lot more.
- Make extensive use of the @available attribute to describe your changes and mark availability
- Start incorporating Swift Markup to make the comments from your Objective-C code more readable.
- Enums pulled in from Objective-C can be made more powerful in Swift by adding methods which work with enums as a part of the enum itself.
- Use property observers to make code more reactive. In some situations this might be easier than setting observers.
Here are some general steps you can follow. The steps below are for both a full app conversion or a piece meal conversion.
Note: The steps mentioned below are sample steps and not necessarily the only way to achieve this.
- If its a full app conversion then create a new project. Else duplicate the existing project.
- Start by looking for the frameworks you need and importing them in the necessary Swift files.
- Identify class(es) that you have in your Objective-C project. Start by creating empty versions of those in your Swift project. It is very likely that you may not need all the classes as you might be optimising or reworking your App’s architecture. Also it is possible that you may need new classes.
- Next identify data structures used in the class. Either convert them to their swift equivalents or explore other options.
- Migrate the functions directly associated with the data structures.
- Migrate the variables used in the Objective-C class.
- Lastly migrate the remaining functions to Swift.
- Do this till you have converted all the classes that you wish to convert.
One point left to talk about is testing. Thoroughly test you app after each step you complete. If you are using XCTests, migrate a single Unit test at a time. Corresponding to the changes that you have made above.
5. Things to watch out for
There are many things to keep in mind while migrating your code.
- In a mixed language project (Swift and Objective-C) Swift only features won’t be supported. So Generic Programming cannot be implemented.
- Blind copying of the code from Objective-C to Swift may not result in the best output. Try to examine each line for potential optimisation opportunities.
- Watch out for OS version compatibility. You may have to choose your Swift version accordingly.
6. Full Conversion versus Part by Part Conversion
- The advantage of building the app from scratch is that your overall development time is less as different parts of the app can be refactored at development time.
- You also have the advantage of adopting new development approaches or architectures such as Model View View Model (MVVM) or Test Driven Development (TDD).
- You are in a better position to take advantage of all the Swift features as there won’t be any challenges with compatibility.
- The advantages of Swift viz: Speed, Safety, and compact code are more easily achieved
- If you want to support older versions of iOS then having a pure Swift and pure Objective-C version helps.
- Of course this means that your development time is large.
- There is a potential for writing duplicate code in Swift especially if it is being reused in Objective-C projects. You may end up with 2 code bases for the same feature.
- The advantage of migrating parts of your app is that you can split the migration over a larger period and use your resources on other projects.
- In terms of cost this is less expensive and more resource friendly
- The potential for duplicate code is reduced
- But on the flip side every time you take a new part to migrate you will have to make changes to the Swift code written earlier. This increases the development time and may affect the quality of the app in the long run.
- You cannot take advantages of all the Swift features.
- There is a chance that once the migration is complete the App may have to undergo an overhaul to take advantage of the Swift features & improve on Speed, Safety & Size.
This article just talks about some of the advantages and challenges with Migration to Swift. There are multiple approaches available and you will have to pick and choose the approach based on your needs or situation. I had written an article some time back about choosing between Swift & Objective-C, you can have a look at that too. Here is an article, for your reference, written by Apple on Migrating to Swift. Good luck & Happy Programming! Do feel free to share your experience migrating to Swift.