A decade ago, if you wanted to build a mobile app, you had two main options: either native iOS or Android, or hybrid frameworks like Ionic or Cordova, which were essentially web-to-mobile converters. And yes, while technologies like Xamarin and Windows Phone also existed, they are far less common today. Nowadays, for the same mobile app, you have at least five different technologies you can use to build it, and that makes it quite difficult to choose one, either for building the app or for making a career out of it.

In this article, we're going through all the options, looking at the technology behind them, the programming languages, and the tools you can use. This is a necessary step before diving deeper into all these technologies in future articles. So whether you're already a mobile developer or you're an aspiring one still learning, by the end of this article, you'll know exactly what your options are for building a mobile app or for a career in mobile app development.

The Enduring Power of Native Apps

Contrary to many predictions, native apps didn't go away; they are here to stay. Native refers to the technologies that Apple and Google made available for developers to build apps for iOS and Android, respectively.

On the iOS side, we have Swift, a powerful and intuitive language introduced by Apple in 2014. But everyone talks about SwiftUI; what's that? We'll get to that in a moment. Some of its key features are performance, safety, and an intuitive syntax. To see for yourself, here's a comparison between Objective-C and Swift.

Objective-C Example: ```objectivec

import

int main(int argc, const char * argv[]) { @autoreleasepool { NSString *greeting = @"Hello, World!"; NSLog(@"%@", greeting); } return 0; } ```

Swift Equivalent: swift let greeting = "Hello, World!" print(greeting)

It's no wonder that Swift became the preferred one.

On the UI side, for a long time, we used UIKit, which is a framework for creating UI with Storyboards or XIBs (drag-and-drop interfaces) or directly from code. UIKit uses Auto Layout and constraints, which allow for fine control of UI elements and how they are positioned next to each other or on the screen. However, it can take a lot of time to build complex UIs.

So now we have SwiftUI, which is a newer, more modern framework for building UIs in native iOS apps. SwiftUI has live previews and a declarative approach to building the UI, so overall it reduces the amount of code that's needed for creating especially complex UIs. And yes, that code is still Swift, so SwiftUI is not a language on its own; it's just a framework.

As for tools, the bare minimum you need is Xcode and a Mac. Yes, that can be a drawback; you cannot build native iOS apps on Windows or Linux. I mean, there is a way, but more about that in a few minutes. Xcode is the IDE for building native iOS apps, and it has tools like a debugger, performance analysis tools, and simulators, so you can test your app on multiple devices. If you ever check the reviews on the App Store for Xcode, you'll see it's a love-hate relationship—mostly hate. iOS developers love to complain about Xcode, and they have reasons.

Additional tools to mention are CocoaPods and Swift Package Manager for managing dependencies, and App Store Connect and TestFlight for distributing your apps either to testers or on the App Store.

Diving into Native Android Development

Alright, let's move to Android, where Kotlin is the main programming language. What about Java? You can build Android apps in Java, and it was the first programming language used for Android development. But Kotlin is a more modern language with a shorter and simpler syntax and features like null safety, extensions, and coroutines for asynchronous programming. So please, if you make Android apps, use Kotlin. It runs on the Java Virtual Machine and it's fully compatible with Java, so if you need to have both in your project, that's also an option. As a fun fact, Kotlin is named after an island near St. Petersburg, so it seems like programmers really like naming programming languages after islands.

On the UI side, for a long time, you had XMLs for building UI components on Android. Each screen or part of a screen was a separate XML file, and you had to write all the components and the constraints between them in that file, and it can get quite messy if the project grows. Nowadays, we have Jetpack Compose, which is a more modern toolkit. It has a declarative approach which reduces the overall code, and you write code in Kotlin. It's the best—it's kind of the SwiftUI of Android.

On the tool side, the go-to IDE is Android Studio, which, similar to Xcode on iOS, has performance monitoring tools, debuggers, many additional cool features compared to Xcode, and also a built-in emulator for testing on different devices. If you've ever used Android Studio, you know it's kind of a Russian roulette game; you never know if they fix bugs or if they add new ones. Additional tools include Gradle for building the app and its modules and also for managing dependencies, and Firebase App Distribution or the Google Play Console to share your app with either beta testers or on the Google Play Store for everybody.

The World of Cross-Platform Frameworks

Alright, now that we've explored the native options, it's time to move to the world of cross-platform frameworks and apps. We will talk about three major players in this space: React Native, Flutter, and Kotlin Multiplatform.

Unlike on native, where you have separate codebases for each operating system, with cross-platform, you can have a shared codebase and deploy your app on Android, on iOS, and sometimes even on web and on desktop, which can increase both the consistency and the efficiency of app development. But how can this be? How does it work? Well, they provide an abstraction layer on top of the platform-specific code, so you have a unified interface to interact with each smartphone's capabilities. This abstraction layer allows developers to write code in JavaScript or in Dart while still being able to access device-specific features. Of course, they are not a silver-bullet solution for everything and they might come with limitations and trade-offs when it comes to performance, stability, and functionalities.

React Native: The Pioneer

Let's give priority to the elders and start with React Native. It was the first such framework that really became popular. Developed by Facebook in 2015, React Native allows us to create mobile apps using JavaScript and the React library. It was the first solution that offered both a native feel and a shared codebase, so it's no wonder that it increased so much in popularity. As a fun fact, it was created in a hackathon when they wanted to bring the ease and efficiency of web development to mobile. And as you probably know, JavaScript is one of the most popular programming languages in the world, which means it has a large community and lots of resources to learn from.

On the UI side, just like in React, you are using JSX for creating user interfaces. It's an extension for JavaScript that kind of looks like XML. Then, React Native bridges this gap between JSX and native components using the so-called "Bridge," which means that on iOS, it will render native iOS components, and on Android, it will render native Android components. This is quite impressive, and it gives you that native feel and user experience that we mentioned before.

As for tools, the most popular IDE is Visual Studio Code, and you will also use the React Native command-line interface to build and run your projects. Also, probably the best tool we can mention here is Expo, which is actually a set of tools for React Native that simplifies development even more. Expo comes with an additional set of JavaScript APIs that cover the most common features in mobile app development, like push notifications, for example, and you can implement that without writing any native code. You can even build and run your apps on your phone without installing Xcode or Android Studio. Remember what I said earlier about building iOS only on a Mac? Well, Expo is that single other way that you can build for iOS without having a Mac because it offers a cloud infrastructure for that. So yes, Expo is pretty cool. The only downside is that when you use Expo, you are not allowed to write native iOS or Android code for some specific features.

Flutter: The UI Powerhouse

Alright, let's move to Flutter. Flutter is one of the most popular cross-platform frameworks of today. It's developed by Google and it was launched in 2018, so three years after React Native, but it quickly caught up in terms of popularity, even though the programming language that you use is Dart. Dart? What language is that? Yeah, that was my reaction too, but actually, Dart is not that bad. With Flutter, you can create apps not only for iOS and Android but also for web and for desktop, although it's not so often used for web and desktop. Some of the exciting things that it brings are a big set of predefined components, very good performance, and a highly customizable UI.

Flutter uses Dart, an object-oriented programming language. In terms of the syntax, here's how it looks:

Dart Example: dart void main() { print('Hello, Flutter!'); }

On the UI side, Flutter is known for its high customizability and for its fast rendering. This is possible due to the fact that Flutter doesn't rely on native components but it has its own rendering engine called Skia. This means that components are rendered on a canvas and they are not translated into native iOS and native Android components like on React Native. The fun and tricky part about this is that you can create a UI that looks nothing like the operating system you're building for. For example, you can even show the native iOS alert on Android, which is mind-blowing. And the good part about this is that Flutter has very fast rendering, and this ensures consistent performance across all platforms.

As for the tools, you can use either Android Studio or Visual Studio Code; both offer excellent support for Flutter. The Flutter SDK has a lot of pre-built widgets that you can use (widgets are the UI components), and you also have tools like the Flutter Inspector and Dart DevTools for debugging and profiling. Another thing that I want to mention here is its excellent documentation, and probably that's due to the fact that Google continuously supports it and improves on it. So in my experience, learning and using Flutter was quite enjoyable.

Kotlin Multiplatform: The Best of Both Worlds?

This sounds nice, maybe I should switch to Flutter? Wait, there's one more we need to cover, which is Kotlin Multiplatform. Developed by JetBrains, just like the Kotlin language itself, it was launched in 2020, and it's another framework that allows you to reuse code between iOS, Android, and even other platforms. What's different compared to React Native and Flutter is that with Kotlin Multiplatform, you're encouraged to reuse the business logic side of the code. So things like data models, logic for app offline storage, the networking side—all of these you can reuse across different platforms, and then you build the UI separately for iOS and Android in our case on mobile. This provides a good balance of code reusability and that native experience for the user.

This shared code is written in Kotlin, which we already covered when we discussed Android a bit earlier, and this makes it quite a good option for native Android developers who want to try something on the cross-platform side, and even for native iOS developers because Swift is quite similar to Kotlin.

Now, on the UI side, you typically use the native frameworks like SwiftUI for iOS and Jetpack Compose for Android to build the UI separately, which offers a native feel on both of these operating systems. And that's the good thing, but of course, the bad thing is that you have to write the UI code twice. Not four times, twice.

As for tools, you will use Android Studio and the Gradle plugin, just like we discussed earlier on Android, and for the iOS UI side, you can open that project in Xcode and build it like that. Also, you can add different dependencies on iOS and Android; you don't have to add everything in the shared module if you can't or don't want to do that. So yeah, Kotlin Multiplatform is kind of somewhere in the middle between React Native and Flutter, which offer the greatest degree of reusability, and native iOS and Android, where you have to create separate codebases for each platform.

Final Thoughts

Alright, we covered a lot of technologies today. Oh yes, we did. All these? Well, no, there are a few more, but these five are the most promising that you can use today and in the near future. And by that, I mean in more demand on the job market, suitable for the majority of apps, with the biggest communities, and offering a good balance between performance, speed of development, and future support.

As a sneak peek, next we will explore what types of apps are suitable for each of the technologies we covered today and also what's the best fit for each developer's preference, experience, and the job market.