
<LeadParagraphWrapper>
Interoperability of programming languages is the ability for two or more languages to interact as part of the same system. 
Interoperability can offer many benefits for developers. For example, the ability to reuse existing code and libraries across languages and platform, increases the portability and scalability of code. 
This can save time and effort while also improving knowledge sharing and code quality. 
There are many ways programming languages are interoperable with one another. 
Shared object models, foreign function interfaces, common runtime environments and virtual machines are some of these ways. 
For instance, web browsers frequently perform some kind of interoperability. 
Browsers parse HTML to handle information to be shown on a page, and language like JavaScript handle any real-time functionality on the page.
</LeadParagraphWrapper>

### Interoperability in Apple Ecosystem

When you’re building an app target, it is legal for a target to be a bilingual target — one that contains both Swift files and Objective-C files. 
There are several reasons why a bilingual target could be helpful: 

- You might want to use third-party code written in Objective-C or Swift.
- You might want to combine your own legacy project written in Objective-C.
- Your app itself may have been written in Objective-C originally, and now you want to migrate part of it (or all of it, in stages) into Swift. 

The critical question is how Swift and Objective-C access each other's code within a single target.

Unlike Swift, Objective-C files are unable to automatically see one another. 
Instead, each Objective-C file that needs to see another Objective-C file must be instructed explicitly to see that file, with an `#import` declaration at the top of the file.

Typically, an Objective-C class declaration is divided into two files: a header file (.h) containing the `@interface` section, and a code file (.m) containing the `@implementation` section. 
Importing is limited to `.h files` only, so if you want class members accesiable for other files, it must be defined in header files.

>Visibility of Swift and Objective-C works through header files. 

Visibility works on both way thanks to two special Objective-C header files:

### How Swift sees Objective-C

When you add a Swift file to an Objective-C target, or an Objective-C file to a Swift target, Xcode offers to create a `bridging header`. 

![images/bridging-header](/images/posts/1/bridging-header.png)

This is a `header(.h)` file in the project. Its default name is derived from the target name. 
It takes its name from the target name by default. However, the name is arbitrary. If you choose “Don’t Create”, you can create a header file manually and point to it in the Bridging Header build setting. 
If you `#import` an Objective-C header file in this bridging header, Swift will then be able to see it.

### How Objective-C sees Swift

When you build your target, the relevant top-level declarations of your Swift files are automatically translated into Objective-C and are used to construct
a `generated interface header` within the build folder for this target, deep inside your `DerivedData` folder.

![images/bridging-header](/images/posts/1/generated-interface.png)

{/* <Image alt="bridging-header" src="/images/posts/1/generated-interface.png" width = "500" height = "100"/> */}

Your Swift code is exposed to Objective-C in general through the generated interface header. 
Your Swift declarations will be visible to your own Objective-C files if you `#import` the generated interface header into every Objective-C file that requires access to them.

### Interoperability at Compile Time

 Let’s take closer look what happens when we build bilingual target at compiler level.

#### How does Swift import and use Objective-C declarations:

- The Swift compiler phases are parse, semantic analysis, SILGen, IRGen and LLVM.
- Swift compiler embeds Clang (the LLVM compiler) as a library. When you ask Swift to import a module, it attempts to load the module in Swift space by that name. If that fails, it ask Clang to load a Clang module by that name.
- The Clang Importer, a Swift compiler component, will generate comparable Swift declarations for the Clang declarations in that module. The compiler is aware that these declarations actually correspond to declarations in Clang.
- The Compiler checks if the declerations imported from Clang, it calls into Clang IRGen(LLVM’s intermediate representation, this is one of the crucial benefit of LLVM architecture) to generate the code needed. 

#### How does Swift make “@objc” declarations usable from Objective-C:

- Swift IRGen generate Objective-C-compatible metadata for these declarations. It also generate Objective-C-compatible wrapper functions—for Swift functions and methods that should be accessible from Objective-C.
- There are some runtime data structures that were intentionally developed to work with Objective-C. For instance, native Swift root classes actually inherit from a class that conforms to the NSObject protocol. Swift automatically bridges certain types between the two languages, such as NSString and String, NSArray and Array.

### To Sum Up

In a nutshell, Swift does not convert Swift code into Objective-C; nor does Clang convert Objective-C code into Swift. 
Instead, Swift and Clang both translate the source code of their respective languages into IR, which is subsequently passed to LLVM for machine code generation. 
Interoperation is enabled by various tricks. The header files which is created for visibility between swift and Objective-C is just one these tricks.








Swift and Objective-C Interoperability 

<LeadParagraphWrapper>
Swift is a general-purpose, multi-paradigm and compiled language for iOS, macOS, watchOS, tvOS, and Linux applications. Swift is the outcome of the most recent research on programming languages and created by team led by Chris Lattner at Apple.
</LeadParagraphWrapper>

Cocoa programming had always been done mostly in Objective-C, first on Mac OS and then on iOS until that point. The Cocoa frameworks that give an iOS app its functionality are based on Objective-C, they expect to be spoken to in Objective-C. For all its flaws, Objective-C was the language we  learned to live with as the price of Cocoa programming. 

Is it possible to communicate with Cocoa in a different language? This is where possibilities become reality, the answer is yes. Swift is explicitly designed to interface with most of the Cocoa APIs.

Swift is easy to learn and easy to implement, even if you’re a new programmer. Some of the key features:

-   **OpenSource:** Swift’s founders recognized that to create a defining language, the technology needed to be accessible to everyone. With this decision, Swift language gained a large community and a wide range of open source tools.
-   **Object-orientation:** Swift is a modern, object-oriented language. It is purely object-oriented: `Everything is an object`.
-   **Safety:** Swift uses a strong, static type system to ensure that types are correctly matched at compile-time, reducing runtime errors.
-   **Memory Managemen:** Swift manages memory by using Automatic Reference Counting (`ARC`), which removes typical memory management mistakes and improve efficiency.
-   **Modern Syntax:** Swift's syntax is consistent, clear, and expressive, allowing developers to write code that is easy to read and maintain.
-   **Optimized Compiler:** LLVM-based compiler optimizations enable Swift code to be compiled into highly efficient machine code.

### Stable ABI and Backward Compatibility

In March 2019, Swift 5.0 was officially released. It introduced a stable version of the application binary interface (ABI) across Apple’s platforms. 

ABI is an interface between two binary program modules. It is a collection of rules that allow applications and program parts, such as libraries or frameworks, to speak the same "binary language" and interact with one another. 
Typically, the ABI includes the following topics:

- Calling convention (how to call functions, pass arguments, return values)
- How data is represented in memory
- Processor instruction set, stack organization
- How an application should make system calls to the operating system

> You write Swift code and want to share it with many apps. You make a framework and use the Swift 3.0 compiler. Then Apple brings out Swift 4.0. You're excited and make a new app with Swift 4.0 compiler. The problem is that your project requires certain functionalities from your previous framework. Is it going to work with new project? Nope. Before `ABI stability` both pieces of code had to be compiled with the same compiler for them to communicate. So, if your framework was compiled with Swift 3.0 and your app with Swift 4.0, they wouldn't work together. Now, with "ABI stability," things have changed. A framework compiled with Swift 5.0 can communicate with an app compiled with Swift 5.1.

Before stable ABI, the complete Swift standard library and runtime were included in every Swift app that was created. 
This was because Swift was evolving rapidly, making it impractical to include its fundamentals in iOS releases. 
ABI stability refers to the ability of a language to be packaged and linked directly into the operating system.

Swift's system footprint will decrease once it becomes an ABI stable language because apps won't need to package with swift dynamic libraries, and you'll still be able to take advantage of the OS's internal optimizations. 
Another advantage of stable ABI is developers will be able to write closed-source third-party libraries and release them as pre-compiled frameworks.

### Swift in Action: Across Different Areas

Swift is adaptable and works well in a variety of programming scenarios, including server-side development, scripting, automation, and mobile app development. 
Due to its high performance, wide feature set, and clear syntax, it is becoming more and more popular among developers in different fields.

#### Swift in mobile app development

When developing apps for the iOS, iPadOS, watchOS, and tvOS platforms, Swift is mostly used. 
The following benefits highlight some advantages that developers can leverage while creating mobile applications with Swift:

- Swift has ability to integrate with Apple's SDKs and frameworks such as UIKit, AppKit, and SwiftUI.
- Clear and concise syntax makes your code more readable and maintainable.
- If additional developers are required, Swift lets you add them to your team easily, because the codebase is clear and simple, onboarding happens rather quickly.
- Safety features take center stage in Swift, such as optionals and type safety, helps developers write code that is less prone to runtime errors and vulnerabilities. This reduces the risk of crashes and security breaches in mobile apps, providing users with a more reliable and secure experience.

#### Swift in server-side development

Swift has gained interest in server-side development due to its open-source status and high-performance advantages. 
Swift can be used by developers to build RESTful APIs and web applications by utilizing server-side Swift frameworks such as Kitura, Vapor, and Perfect. 
These frameworks enable the following capabilities:

- Developing and deploying high-performance REST APIs for various client applications, including mobile apps and web apps.
- Creating web applications with server-side capabilities such as database access, authentication, file management, and more.
- Designing reusable server-side libraries that the Swift community can use or distribute across several projects.

Swift has a number of advantages for server-side development, including:

- Swift has impressive concurrency and performance support, enabling software developers to design scalable APIs and web applications.
- Safety features and error handling, improving the reliability and robustness of server-side code.
- The capacity to share code between client and server applications, which speeds up development and eliminates redundant code.

#### Swift for scripting and automation tasks

Swift is useful not only for server-side and mobile app development but also for scripting and automation tasks. 
Swift is a compiled language, which means that you typically need to compile your code into a binary before it can be executed. 
However, if you're familiar with Unix shells like Bash or Zsh, you know that scripts written in these shells can be run directly without the need for compilation. 
This is where Swift scripting comes in. By leveraging Swift's interactive shell, known as the REPL (Read-Eval-Print Loop), you can write and run Swift scripts without the need for compilation. 
This opens up a whole new world of possibilities for automating tasks and manipulating data using Swift.

Some common use cases for Swift scripting include:

- Creating and maintaining templates or configuration files.
- Manipulating data, such as transforming JSON or CSV files.
- Implementing batch procedures to big data sets.

### Final Thoughts

Swift is more than just a coding language, it's a transformative instrument empowering developers. 
It helps us to learn new programing paradigms and enhance our ability to design efficient and scalable solutions. 
Swift has changed a lot since it started, and each update has made it better for developers. 
Ultimately, Swift's evolution translates to a more enjoyable and productive coding experience, empowering us to build more reliable applications with ease.





Tagged with #swift

Swift and Objective-C Interoperability

Swift: A Language for Modern Development