Cross-platform development projects are taking us by storm. Over the last years, however, we’ve noticed a general misunderstanding on when it’s right to put native apps aside and go for cross-platform. The reasoning we hear is that it allows cutting costs and development time.

The expectations are high: develop an app that runs everywhere, for less and within a shorter time frame. The native vs cross-platform battle continues.

Let’s see what’s the problem with this is and do a little reality check.  Our goal here is to show some contradictions in the general perception of cross-platform apps so that you can make a more informed decision on cross-platform development.  We’ll leave no stone unturned about the advantages and pitfalls of cross-platform mobile development.

What’s cross-platform all about?

Cross-platform development has been around since the 1970s, C programming language was the first well-known cross-platform solution. It was developed to run code on different platforms by compiling it multiple times for each platform.

Build once – run everywhere.

There are dozens of solutions and tools for the cross-platform mobile development. Developers and clients alike love the concept since it’s often marketed as a way to cut time and cost by writing once and running everywhere. Sounds great, right?

The illusions vanish when they realize that platforms are incompatible, and cannot provide the same functionality as native software. These illusions create problems for many software development projects. They create risks. And risks can kill the benefits.

Principles of cross-platform apps

As computers grew in performance, so-called runtime solutions came into being – like Java language and its virtual machine. It’s a unified environment, where the application is run. Basically, the source code is only written and compiled once.

Another whole world of cross-platform apps are web-based solutions. Here – it’s all about the browser. Since browsers are a part of pretty much any modern operating system, running applications there makes a lot of sense. The code doesn’t even compile since browsers have built-in interpreters.

Probably the best example of web-based solutions are HTML5 web applications. Ever heard of creating hybrid apps? Such cross-platform applications are native but include what’s called a webview to execute the web app. The web view loads the web application from the server and the user interacts with it.

These solutions have a common feature, a layer between the app and the OS – a compiler, a virtual machine, or a browser. Through this layer, the OS accesses the app’s functionality.

But there’s a fundamental contradiction here: the solution has to be implemented for each platform separately. That means each implementation will have its own bugs to fix, versions to maintain, and features to roll out. Even devices by a manufacturer may need to be separate.

That makes the development of cross-platform applications a bad option for cutting costs.  Yet, even if you manage to cut some, it will be “eaten” by bugs, support, maintenance and so on.

This is not to evangelize against cross-platform apps here, we just recommend a deeper analysis of the pros and cons:

Pros Cons
Compile-time solutions Highest performance
Native user experience
Low-level development
Runtime solutions Native user experience High level of development risks
Web-based solutions Simplest development
Wide platform coverage
Lot of restrictions
Non-native user experience

In cross-platform development, everything comes at a cost.

Mobile solutions review

Here’s a more in-depth view of the technologies for cross-platform solutions. Most of them are suited for mobile app development, but some work for the desktop, too. These solutions provide developers with UI kits, APIs, development and distribution tools.

Game development is abundant with compile-time solutions because performance is the top priority here and the UI has to be consistent across all platforms. Compile-time solutions require code translation. The code is written for one of the platforms and then converted to the code of the destination platform. That requires skilled developers.

There are online services that provide tools to build and submit mobile apps to the stores right from the browser. Como, now owned by Swiftic, is an example of such app builder.

Some of the solutions are just UI kits for developers: Mobile Angular UI, jQuery Mobile, and Sencha Touch.

There are also distribution and analytics systems like IBM MobileFirst and Trigger.io.

Compile-time solutions Runtime solutions Web-based solutions
Apps Games
Xamarin Platform
C#
iOS, Android, WP
Unity 3D
C#, UnityScript
iOS, Android, WP
Facebook React Native
JavaScript
iOS, Android
Adobe PhoneGap / Apache Cordova
JavaScript
iOS, Android, WP, Blackberry OS, Samsung Bada, Tizen, webOS
Embarcadero RAD Studio
C++
iOS, Android
Marmalade SDK
C++, Lua
iOS, Android, WP
Appcelerator Titanium
JavaScript
iOS, Android
Ionic Framework
on top of Apache Cordova
JavaScript
iOS, Android
RubyMotion
Ruby
iOS, Android
Cocos2d
C++, Lua, JavaScript
iOS, Android, WP
RhoMobile Suite
Ruby
iOS, Android, WP
Intel XDK
on top of Apache Cordova
JavaScript
iOS, Android, WP
Qt
С++
iOS, Android, WP
Corona SDK
Lua
iOS, Android, WP
Trigger.io
JavaScript
iOS, Android
IBM MobileFirst Platform Foundation
on top of Apache Cordova
JavaScript
iOS, Android, WP, Blackberry OS
RoboVM
Java
iOS, Android
Unreal Engine
C++
iOS, Android, WP
Adobe AIR
ActionScript
iOS, Android
Telerik Platform
on top of Apache Cordova
JavaScript
iOS, Android, WP

Compile-time/runtime/web-based?

Let’s define the most important goals for cross-platform mobile development:

  • unified development process;
  • cost cutting;
  • faster development;

The platform’s API has a fundamental effect on these goals. For compile-time solutions, your developers have to know all the APIs of the destination platforms. They have to write different code for each platform. That leads to higher cost and longer development times.  As a result, there’s no unified development for you here.

The runtime and web-based solutions ensure the development is unified. But the restricted access to APIs will make you build custom solutions and workarounds, spending more time and money.

Mobile apps are mostly user interface (UI), so that’s the main effort. The compile-time solutions require almost as much effort as native apps when it comes to UI. While web-based solutions may be more affordable, they can fail to provide top-notch user experience (UX).

book-img

How to Build a Mobile App and Not Fail Miserably

Everything you need to know about building, launching, distributing, and monetizing a mobile app for your business.

Download free e-book

Comparing your options

Compile-time solutions Runtime solutions Web-based solutions
Platform APIs Proxy access Wrapper with its own unified APIs No direct access
UI Native. Different for each platform Native. Some UI elements are unified, others are not Not native. Unified
3rd party SDKs The developers have to integrate The developers have to write native bridges The developers have to write native plugins. There are many ready-made ones, though
Security The code is compiled and is not accessible The code is a string and can be changed during execution The code can be located on the server and can be changed during execution
Debug and tools Solutions own and native tools can be used. Own or 3rd-party tools can be used Any web tools can be used
Maintenance The new APIs cannot be supported without solution update New APIs cannot be supported without solution update. The solution update can affect the app current version The new versions of the webview have affect the app and have to be supported
The new APIs cannot be supported without a solution update. The solution update may affect the app current version.The platform-specific features (like background tasks) are really hard or impossible to support without native modules
It’s almost always a challenge to support new versions of the 3rd-party SDKs
Team structure Homogeneous, but it’s necessary to know platforms’ APIs, UI and tools Homogeneous, but native development is necessary to support 3rd-party SDKs Homogeneous, but native development is necessary to support 3rd-party SDKs. Have to know the difference between the platforms’ own webviews

Any integration of 3rd party SDKs (software development kits) increase their budget and the terms for cross-platform solutions. It, again, makes unified development close to impossible.

With runtime and web-based solutions changing the code can be a challenge for security. But it can also be the advantage as it allows updating the applications, bypassing the app stores.

Debugging cross-platform apps

Even though all the solutions above have standard debugging tools, identifying and debugging are in fact more complicated for cross-platform than for native development. Cross-platform environment undermines understanding of the crashes and performance. Hence, in some cases, that can dramatically increase the debugging effort required.

Sometimes it’s necessary to support obsolete platforms. In such a cases, cross-platform mobile solutions can be the only way out. But make no mistake here: each solution supports its own set of the platforms.

Maintenance

Everything depends on the application version here.

Developers have to wait for the solution to add support new features and fix some bugs. It increases the project terms. While developers can implement workarounds, it still increases both the terms and the budget.

One of the important advantages of the cross-platform mobile development is a homogeneous team. But it’s impossible to exclude a platform’s specific issues. Therefore, a part of the native development has to be applied. It increases the budget and the terms and makes fully unified development impossible.

Risk analysis

Cross-platform mobile development creates risks that are absent in the native projects.

We’ll go through some of the risks that have a direct influence on the project budgets and terms.

The main advantage here is the single code base, with some challenges and limitations, of course. The risk is that you will have to create separate solutions to make that code base work with different platforms. That can make the developers write more complex code or integrate more 3rd party solutions to address the platform-specific issues. Again, that’s  more time and money.

Consequently, all these risks ultimately lead to the necessity to write custom native code. It’s the worst case for any cross-platform project.

The cross-platform mobile development team

By now, it should be pretty clear that that cross-platform mobile development requires more attention to the architect role in the team. He or she should be the one keeping spaghetti code out of your project and making sensible decisions on technologies and practices.

The team is your most valuable asset, and a source of some risks, too. Platform knowledge, or rather its absence, can cause reworks. Even if a single platform is unknown to the team, it takes time and money to deal with. Furthermore, the solutions have their own features, APIs, and issues the team must know. So again,  unified development is hard to achieve.

Because that’s a lot of information to chew, here’s a basic breakdown of risks.

Risks Compile-time solutions Runtime solutions Web-based solutions
Only a small part of the code will be common High Medium Low
No standard frameworks available High Medium Low
Very complex architecture and code High Medium Low
Spaghetti code High Medium Low
Too much custom solutions Low Medium Medium
Workarounds Low Medium Medium
Writing native code Low Medium Medium
Cross-platform environment issues Low High Medium
Platform features not supported Low High Medium
UI Kit issues Low Medium High
Troubles with debugging and bug fixing Low Medium High
Troubles with testing Low Medium High
No mobile expertise will have effect High Medium High
Need to learn the platform’s features High Medium Low
Need to learn solution’s features Low High Low

The benefits of cross-platform mobile development

The risk analysis above shows that the fundamental goals of the cross-platform mobile development are really hard to achieve. But, that doesn’t negate all the benefits.

Easier to find developers

Due to the wide range of solutions involved, finding developers across many platforms is easier (JavaScript, C#, C++, etc).

Great community

You can bring in well-known web and other frameworks to mobile development. Such technologies boast a great active community, that constantly contributes to the evolution of the platforms. You can harness the power of the community for your project.

Faster hiring and project launch

Popular programming languages mean it’s easier to hire developers. Project requirements stay the same, while your people work with a well-known technology. Such teams can deliver a minimum viable product (MVP) in very short timeframes. This benefit works well enough with the web-based solutions.

The team, however, will have to spend the project’s resources to get mobile expertise.  As a result, it will be necessary to evolve the project taking that into consideration.

Reducing overhead

Another benefit of the cross-platform mobile development is a reduction of management overhead.  The project manager, team lead, architect will manage the single project but not for each platform.

Sometimes it’s necessary to support obsolete platforms. In such a cases, cross-platform mobile solutions can be the only way out. But make no mistake here: each solution supports its own set of the platforms. You cannot always choose the technology you want.

TL;DR

We’ve gone through the well-known cross-platform mobile solutions, the most important contradictions and the risks.

The analysis shows that:

  • there are very high risks that cross-platform mobile development will add costs and terms, not reduce them;
  • the cross-platform team can’t be fully homogeneous and the developers have to learn the platforms they’ll be working on;
  • the cross-platform approach allows to start the project faster;
  • the wide web development community can be involved in the mobile development;
  • the more complex the project is, the higher the risks to exceed the budget and the terms compared to native development;

Each cross-platform solution has its own pros and cons as described above.

Compile-time solutions are the only choice when performance is the goal. Otherwise, they are really close to native development;

Time solutions allow creating apps with a real native look and feel.  However, they are quite risky because of own APIs, and unsupported features;

Web-based solutions have a lot of restrictions due to the high-level environment. The maturity of web technologies and community allow cutting the risks and ensure maximum platform coverage.

Many cross-platform technologies are less-expensive in terms of developer salaries. In addition, you can achieve lower costs by hiring cheaper developers.

So, the main problem with cross-platform development is the universalism. The universal solution can solve a variety of tasks, but it can’t solve tasks better than a specialized one. For instance, the computer mouse allows to interact with any application but it isn’t as comfortable as a joystick for gamers or graphic tablet for painters.

But sometimes cross-platform is the only way to implement the mobile development app project. That’s especially the case with obsolete platforms.

Artem Petrov

CEO at Reinvently

Artem is a serial entrepreneur and the CEO at Reinvently. His background in applied mathematics, software development, and interface design spans 15 years of experience in building better businesses with mobile tech.

Looking to build a beautiful and smart mobile product for your business?

Let’s make it happen.



1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...