Cross-platform mobile application development on what to write. Cross-platform mobile app development. Director for Technological Development of the IT company "ID - Management Technologies"

Mobile applications have become a constant companion of our life. With their help, we can not only have fun and simplify our life, make purchases or order certain services online, but also promote our business, increase the client base, and, consequently, multiply profits. And if no one can have doubts about the need to create an application for their business, then some difficulties may arise with the choice of the type of mobile-app.

All modern applications for mobile devices can be divided into native and cross-platform, and each of these two groups has both its strengths and weaknesses.

Native applications are those developed specifically for a specific platform in the corresponding programming language. So, when creating an application for Android, Java is used, and for IOS applications, Objective-c or Swift. When creating such projects, specialists take into account all platform features, paying special attention to UI / UX design, requirements / recommendations of operating system developers, as well as the latest trends in the mobile industry. One specialist will not be able to fully master all of the above languages, therefore, to develop one native product for different platforms, it is necessary to involve different developers, and this is an additional cost, and the development time will be impressive. But at the same time, applications will be "sharpened" for a specific platform, will have access to the internal resources and functions of the device and will work as efficiently as possible.

Despite the considerable list of advantages of native development, clients do not always want to spend time and money on their development, involving several wizards in the creation process. The best option in such cases is cross-platform development, which allows you to create applications for any platform using standard web technologies. In this case, the development can be carried out by one person who has the necessary knowledge and experience in working with HTML5, JavaScript and CSS3. Cross-platform development can be compiled to .apk file for Android and to .ipa file for IOS. Thus, on the basis of one development, you can get two applications for popular operating systems, spending less time and money. However, such developments have their drawbacks, therefore, it is highly desirable to approach each specific case individually and choose the most suitable option - native or cross-platform development.

Client and server parts of the application

Most serious applications have their own client side, which is often called the frontend, and the server side - the backend. The frontend is responsible for what you see on the screen of your mobile device, that is, the entire visual presentation of the application, including the design, size and position of windows, menus, buttons, arrows and any other elements. Also, the frontend is responsible for the application's reaction to certain user actions aimed at moving to different sections of the app, calling new menus, and so on.

The backend is the back end of the application and is located on a remote server that can be located anywhere and controlled using a wide variety of software tools. The relationship between the client and the server is done through the API (Application Programming Interface). In other words, the API is a kind of intermediary between the frontend and the backend, which transfers requests from the client side to the server, returning the data the user needs.

Front-end development

The client part of the application is extremely important, since it is with it that the user himself will deal and his general understanding of the operation of the app will depend on the convenience of the frontend. It can be developed both manually, but for this you need to be well versed in HTML5, CSS3 and java-script, as well as with the help of so-called frameworks. In the first case, the Apache Cordova development environment, also commonly known as PhoneGap, is often used. Using this framework, you can create applications for any platform using web technologies that Cordova translates into platform-specific code. Cordova opens up virtually unlimited possibilities for web developers who don't have to learn Objective-C or Swift, Java or Kotlin to create applications for specific operating systems.

While Cordova has no limitations in UI and logic, frameworks offer ready-made templating solutions. On the one hand, this significantly speeds up and simplifies the development process, since a specialist can use ready-made buttons, lists, input fields, cards and other UI elements. On the other hand, a specialist can use for development only those tools and elements that are available in the chosen framework. The most popular of them is Ionic, which allows you to create cross-platform applications for every taste. This framework has a large built-in collection of standard elements that visually mimic native apps, but can be redesigned as needed. In this case, the developer can connect many additional plugins that extend the capabilities of the ionic framework, and a project created on this framework can be launched directly in the browser window and evaluate how the created application will look and work without the need to use an emulator or install on a smartphone.

Backend development

While the front end is handled by designers and developers with knowledge of HTML, CSS, JS and frameworks, the backend is handled by programmers from a different profile. To configure the servers, different programming languages ​​and tools can be used, the main thing is to properly configure their work and the relationship with the client part. Here it is necessary to use suitable database management systems (databases). It can be traditional MySQL, Redis, PostgreSQL, or any other database (for example MongoDB) that is suitable for the implementation of a specific project and in which the backend developer is well versed. Developers can use PHP, NodeJS, C #, Ruby, Python, Java, and other programming languages ​​to build the back end of an application.

KitApp mobile studio specialists approach the development of frontend and backend parts comprehensively and responsibly. Our developers will create for you a cross-platform application of any complexity and focus as quickly and efficiently as possible! Contact us and our specialists will promptly advise you on all questions of interest!

Cross-platform applications - to be or not to be? This is not an easy question, since each business has its own goals and requirements for mobile applications. But today we will definitely figure out which development is right for you.

What are cross-platform apps?

Cross-platform applications are applications that are developed and then run immediately on both Android and iOS. The essence of the development is that the source code of the application is translated into native code, that is, understandable for a specific mobile device. As a result, the program can interact with the operating system installed on it.

Recall: native applications, as opposed to cross-platform, are written for a specific OS.

Pros of cross-platform development

• expanding the user base due to the appearance of the application simultaneously in several stores;
• single source code saves you the hassle of hiring multiple developers for each platform;
• 75% of the codebase of a cross-platform application can be reused, adapting it for new projects.

Cons of cross-platform development

1. High dependence on a mobile device

Cross-platform apps usually don't work offline. Therefore, their capabilities are highly dependent on the presence of a stable Internet connection. The operating system version and model of the device are also important. A cross-platform application is almost guaranteed to degrade the performance of a device older than one to two years. While the native application will work stably even on an ancient gadget with outdated firmware. So if you don't want your customers to read angry reviews about how your application finally "finished off" someone's smartphone, choose native development.

2. Unfriendly user interface

Users get so used to the look and feel of their gadgets that they expect maximum responsiveness from the applications installed on them. They want to be sure that each button will be in its rightful place, that the page scrolls at the speed that is optimal for them, and that any action they take will be followed by an immediate reaction. Cross-platform applications usually have a hard time adapting to the device, and they cannot boast of high-speed performance.

The problem is that there are no guidelines for cross-platform development - development standards from the creators of the OS. Therefore, a cross-platform application made "for Android" will not be convenient for the iOS user, and vice versa. You can, of course, create separate designs for each platform, but in terms of labor costs, this will be equal to creating two different applications, albeit in the same language.

3. Struggle for primacy among development tools

In the market for solutions for cross-platform development, competition is getting tougher every day. So far, the most popular among developers are React Native and Xamarin, but they may well be outstripped, for example, by Vue Native. In this case, the ex-leaders of the race will lose their most important advantage - the operational support of the code. And this can happen with any cross-platform tool.

This is not a problem for native development. The introduction of new tools occurs gradually, and knowledge of several programming languages, which is mandatory for a narrow specialist, will allow him to quickly deal with all the innovations. In addition, there are huge professional communities around each operating system, as a result of which any difficulty that arises is solved by searching for a similar problem on the forums, where thousands of people are ready to suggest and help solve it.

Which app is right for your business?

Before answering this question, it is imperative to analyze your business. Customer segments, the value of time and money resources, the desired depth of application integration with user devices, plus clearly defined long-term goals - the minimum on which your choice will depend. But we will make it easier if you answer the relevant questions right now.

1. What is your audience using?

If you know that your client base is close to 50-50 for iOS to Android users, choose native development. This will show that you respect the needs of all your customers equally, regardless of their income level.

The relationship between the choice of a mobile device and the level of solvency was once again confirmed by App Annie. A study of the number of downloads and sales of mobile applications in Google Play and the App Store in the first quarter of 2018 revealed that users of Android smartphones downloaded 135% more applications than visitors to the iOS store. At the same time, the App Store brought its owners 85% more revenue than Google Play.

The path to success is clear: play on two fields at once. More precisely, in two stores. Just calculate in which one the application should appear first. Unless the simultaneous release is part of your digital strategy, of course.)

2. How much time do you have for development?

The financial costs of the project depend on the answer to this question. The fact is that from the point of view of the time spent on development, a cross-platform application only seems to be a more profitable solution. In fact, adapting it to platforms can take almost as long as creating two native applications, since developers have to write additional pieces of code for problem areas.

With a native application, there will definitely not be such problems, which is very important for retaining an audience that is extremely intolerant to errors and bugs. According to statistics from Compuware, 79% of users are ready to restart the application if it does not work correctly during the first launch, but only 16% agree to give it another chance. The rest will most likely just uninstall the program.

3. What features of the device do you plan to use?

We have already talked about the fact that only native applications are able to reproduce heavy graphics quickly and without loss of quality. But the technical advantages of native development don't stop there. Take the Facebook app as an example. Due to the release of separate versions for Android and iOS, scrolling has become smoother, image loading times have been reduced and all cache issues have been resolved.

Moreover, native apps get direct access to all services on the device, which allows you to get information about the user's location or their contact list. Cross-platform applications have to use special native plugins, which negatively affects the data transfer speed and overloads the device's RAM.

4. What results are you striving for?

A digital strategy is a list of goals that your company can achieve using digital tools. The choice of the latter largely depends on the benefits that you want to get in the end.

Break down the process from idea to result point by point, taking into account all available resources. Discoveries can be the most unexpected.

For example, you may find that it is too costly to translate your responsive site with many features and interactivity into a cross-platform application, as you originally intended. Or finally make sure that a mobile site always loses to a mobile application - how cross-platform development loses to a native one. And among the reasons, find those that we described above.

Conclusion: a cross-platform application is beneficial only in one case - you create a demo version of the application, limited in time, money and narrow-profile specialists. In all other cases, a native application will give you many times more advantages, since this is a qualitatively different level of development.

Cross-platform development allows you to create a mobile application that will simultaneously function in the iOS and Android environments. This is a budget-friendly alternative to building an application for each operating system separately.

Features of cross-platform development

Developing one application for different platforms is both good and bad at the same time. Good, because it can be made faster and cheaper than several applications for each operating system. And that's a bad thing, because the trade-off is reflected in the performance of the application.

These features must be taken into account before starting a project:

• In a cross-platform environment, the code is written once... To make the application work on a different operating system, the code is translated into another programming language. The time and money spent on development is 1.5 times less.
• The applications may not work correctly. In cross-platform development, it is impossible to take into account all the nuances of working with the architecture of each operating system, so applications can run slower than those designed specifically for iOS or Android.
• The interface and requirements for the design of elements are different for different operating systems.... For example, iOS lacks a Back button like Android does. When developing a unified design, this point must be taken into account: in iOS, the button will either remain but will not work, or it will have to be cut manually, and this is additional work with the code.

Most errors of transition from one platform to another are eliminated manually, but it is impossible to completely solve the problems of adaptation to a "non-native" operating system.

So cross-platform development is bad?

No, cross-platform development is okay if you don't demand more from it than it can give.

You can choose this option in the following cases:

• Cover all operating systems on a limited budget. If your target audience is more active on iOS or Android, you can start with a native app for one operating system. If maximum reach is important right away, it is better to choose the cross-platform option.
• Check niche... If you have a promising idea, but you are not sure that it will work, immediately investing a large budget in the development is risky. It makes sense to start with cross-platform development, study user reactions and make strategic decisions based on this.
• The application does not use complex animations or calculations. These operations seriously load the device, and the cross-platform application is not optimized for the full use of the resources of a particular platform.
• The app uses only the basic functions of the device... Show information, upload files, use geolocation, place an order - a cross-platform application will cope with all this. Deeper integration of device capabilities is required - you will have to choose native development.
• Corporate application for employees. If an application is developed for narrow internal tasks and people will work with it through personal gadgets, a cross-platform application will be the best option.

There is no one-size-fits-all answer to the question of whether cross-platform solutions can be used for your project. Fill out the form below: we will study your project and select the best option for its implementation.

Smartphones continue to conquer more and more space under the sun, not only as a tool for consuming pictures of cats and xxx videos, but also as a working tool. Therefore, the demand for mobile development is growing. It is generally accepted that labor and cool are Objective-C / Swift for iOS and Java / Kotlin for Android. There is no doubt, hard and cool, but there are a large number of real-life scenarios in which the use of cross-platform frameworks is more preferable in comparison with native tools.

Some developers expect cross-platform frameworks to solve all their life problems, while others take them with hostility. Both "warring camps" have their own delusions, caused by a lack of understanding of how and what works. This adds fuel to the fire, as emotions are used instead of technical arguments.

Also among developers, especially beginners, there are many myths about cross-platform mobile frameworks. In our article, we will analyze the most popular ones. But first, let's look at mobile development through the eyes of a business that gives money for all IT blackjack.

Why cross-platform tools are needed?

Historically, there has always been competition in the computer market, and each manufacturer provided an optimal set of so-called native (native) tools for developing applications for their operating systems and devices.

Native tools = provided by the owner of the ecosystem.

All other signs of "nativeness" are SECONDARY - the behavior and interface of applications, access to OS capabilities, performance, and so on.

In addition, it almost always turned out that native tools are incompatible with each other, not only at the level of development languages, conventions and architectures, but also at the level of mechanisms for working with the operating system and libraries. As a result, to implement the same algorithms and interfaces, it was required to write an application for several environments in different programming languages, and then support it on the basis of “one command per platform”. At the same time, the capabilities and appearance of applications on different platforms are almost always 90% identical. For the sake of interest, compare the implementation of your favorite programs for iOS and Android.

The second important point is the presence of the necessary knowledge and experience within the team: if they do not exist, then it will take time for training.

In order to solve both of these problems, cross-platform development tools (not only mobile) have appeared on the market for a long time, offering:

• maximize a common code base in a single programming language to make the product easier to develop and maintain;
• use existing competencies and specialists to implement applications on new platforms.

Since there are a lot of programming languages ​​(and environments) now (and specialists who know these languages), there are a fair number of tools for cross-platform development. As an example, we will focus on the popular in our area PhoneGap, Xamarin, React Native and Qt.

Now we can talk about myths.

Myth 1. Magic

The most common myth that haunts the minds of novice developers is associated with the belief in super-algorithms (and super-programmers who created them), which magically turn cross-platform applications into native ones. Something in the spirit of "converting JavaScript code into Swift and then compiling a Swift application." This myth is fueled by the developers of cross-platform tools themselves, promising the creation of "native applications" at the end. And it's not that someone is cunning here, but a rich imagination and a lack of understanding of the basic mechanisms sometimes lead developers to think about shamanic techniques.

The main principle behind cross-platform solutions is to split the code into two parts:

• cross-platform living in a virtual environment and having limited access to the capabilities of the target platform through a special bridge;
• native, which provides application initialization, lifecycle management of key objects, and has full access to system APIs.

In order to connect between the "native" world and the "cross-platform" world, it is necessary to use a special bridge, it is he who defines the capabilities and limitations of cross-platform frameworks.

When using a bridge, performance is always degraded by converting data between "worlds" as well as converting API and library calls.

So, all cross-platform applications must have a native part, otherwise the operating system will simply not be able to run them. So let's take a closer look at what system APIs and mechanisms are provided by iOS, Android and Windows themselves. Let's move on to the next myth.

Myth 2. Not native!

So, we have a cross-platform part of the application that lives in a virtual environment and interacts with the operating system through the framework infrastructure and the bridge.

All operating systems: iOS, Android and Windows UWP - provide access to the following subsystems (sets of system APIs):

• WebView (the web browser embedded in the application) is used in hybrid PhoneGap applications and is effectively the local website runtime;
• JavaScript engines are used in React Native and analogues to quickly execute JS code and exchange data between Native and JS;
• OpenGL ES (or DirectX) is used in game engines and applications in Qt / QML or similar to render the interface;
• The UI subsystem is responsible for the native user interface of the application, which is relevant for React Native and Xamarin.

Cross-platform applications have a native part and the same full access to system APIs as “native” applications. The difference is that the call to the system method goes through the bridge and the framework infrastructure:

WebView- the application lives in its web browser, similar to a one page website. No access to native controls (buttons, lists, etc.), everything is based on HTML / CSS / JavaScript. On the other hand, a web developer will feel like a fish in water.

JavaScript engines became popular relatively recently, as in iOS, a similar mechanism was added only in version 7.0. Of the features, it is worth considering the need to serialize complex data structures to JSON, transmitted between JavaScript and Native environments. To briefly describe such a class of solutions, then in the JavaScript environment the JS code that controls the native application is executed.

OpenGL ES and DirectX are low-level subsystems and are used for rendering the user interface in games and, for example, Qt / QML. That is, when using OpenGL / DirectX, developers themselves draw controls and animations, which can only be similar to native ones. On the other hand, it is a low-level subsystem with very high performance, which is why it is used in cross-platform game engines as well.

All cross-platform applications have a native part, and therefore, potentially the same full access to system APIs as “native” ones. Also, cross-platform applications are built and packaged by “native” tools into “native” installation packages. The key question is how the interaction between the cross-platform part and the native one is organized. For example, inside WebView or using Open GL ES / DirectX, there is no way to create a user interface with a completely native look'n'feel, but at the same time there is full access to GPS, Push notifications and other functionality. And JavaScript or C # code is quite free to control the native application and its behavior, providing a completely native look'n'feel.

To summarize - yes, it is "non-native" from the point of view of the development tools used (not from Apple, Google). But an application can be completely native in terms of accessing system APIs and provide a completely native look and feel. And we are moving on to the next myth.

Myth 3. Crutch on a crutch

It is worth understanding here that native APIs are not considered crutches by default (although there are different opinions here too), so all the indignation is directed towards the cross-platform part. Obviously, the runtime environment (for example, WebView, JavaScript engine or Mono) is also difficult to call a crutch - mature mature solutions with a long history.

It seems that the crutch is how the cross-platform part integrates with the native one. To better understand how different frameworks work, we will look at the mechanisms of operating systems that are used to link the cross-platform and "native" parts using the example of PhoneGap, Xamarin, Qt and React Native.

We'll start with PhoneGap. Below is the high-level architecture of an application based on this framework.

A PhoneGap application is in fact a native application that displays a WebView as the only UI control. It is through him that interaction with the native part takes place. All standard WebViews in iOS, Android and Windows UWP support the ability to add your own native handlers for JS properties and methods. At the same time, the JS code lives in its own isolated environment and does not know anything about the native part - it simply pulls the necessary JS methods or changes the necessary JS properties. Everything inside the standard web DOM, which simply adds new elements associated with the native implementation.

When creating applications in React Native, the developer will almost always need to implement the native part in Objective-C, Java or C #, and the native application itself will be controlled from JavaScript. In fact, the JavaScript engine is a WebView control that is available separately. Interaction goes through the same JS bridge as in the case of PhoneGap. However, in React Native, the JS code does not manage the web DOM tree, but the native application.

Please note that due to iOS limitations (there is no way to implement JIT) JavaScript code is interpreted on the fly, not compiled. In general, this does not really affect performance in real applications, but it is worth remembering.

Now let's take a look at classic Xamarin.iOS and Xamarin.Android, since Xamarin.Forms (which supports Windows UWP) is an add-on on top of them.

Xamarin uses the Mono library to communicate with the target operating system, which allows native code to be invoked using the P / Invoke mechanism. It is also used to communicate with native APIs in iOS / Android. That is, for all public native API methods, wrappers are created in C #, which, in turn, call the system APIs. Thus, all system APIs can be accessed from a Xamarin application.

And finally, let's take a look at Qt, as there are many questions about it from experienced developers.

Qt is a "thing in itself", it has both advantages and limitations. The Qt libraries simply plug into the C ++ system APIs found on all operating systems. For rendering the user interface, low-level mechanisms are used, but their own graphics engine that supports styling "under the native". At the same time, on Android, you have to access the Java API through a special bridge (JNI bridge), and for Windows UWP, use the Open GL ES to DirectX call converter, since Open GL is not available for UWP.

To summarize: all cross-platform frameworks use standard native capabilities of operating systems, are mature, created by experienced teams and the open source community with the support of the giants of the IT industry. Finally, it's time for the “strongest” argument.

Myth 4. Slowly

An important trump card that people like to use in debates about cross-platform frameworks is poor performance. Again, it depends on what to compare with and in which parrots to count.

Recall that a feature of cross-platform applications is the parallel existence of two worlds connected by a bridge:

• PhoneGap: HTML / JS and Native Java / Objective-C / C #;
• React Native: JS and Native Java / Objective-C / C #;
• Xamarin: Mono and Native Java / Objective-C;
• Qt: C ++ and Native Java / Objective-C.

Thus, when comparing performance, it is necessary to take into account the speed of work:

• cross-platform part;
• native part;
• bridge.

If you type in a search engine, for example, react native vs swift performance, you can look at many different tests, and many of them note that performance drops dramatically when the bridge is actively used, including actively manipulating the UI from cross-platform code. For Xamarin, the situation looks the same - the cross-platform part is very fast and comparable to the native one in data processing, however, when using the bridge, performance may decrease. Qt generally operates at the C ++ level, which is fast on its own. If we consider solutions based on PhoneGap, then performance here will greatly depend on the WebView, but still you should not actively change the UI in JavaScript code or carry out scientific calculations.

Slowly? Yes, performance drops are possible due to inept interaction with the operating system through the bridge. However, the cross-platform worlds themselves are as fast as the native ones.

The mobile apps market is over ten years old, but it is still developing rapidly. The demand for companies is constantly growing and it still significantly exceeds the supply, which leads to a constant rise in the cost of development. One of the solutions to reduce the cost of this process is cross-platform development, when the same code is used on all platforms.

Last time we touched on cross-platform mobile app development and a lot has changed since then. It's time to talk about methods and tools again.

Let's start by going over the terminology again.

Relatives

If developers in the process of writing an application use a programming language adopted for a specific platform, be it Objective-C and Swift for iOS or, such an application will be called native (from English native - native, natural).

Benefits of native apps:

• speed of work and response of the interface. The application responds to pressing instantly, there are practically no delays in animation, scrolling, receiving and outputting data;
• clear and simple access to the functions and sensors of the device. For the developer, it is not a problem to work with geolocation, push notifications, taking photos and videos through the camera, sound, accelerometer and other sensors;
• the possibility of in-depth work with the functions of a smartphone. As in the previous paragraph, things such as animations, the creation of complex interfaces and the operation of neural networks directly on devices are implemented, perhaps not simply, but predictably;
• ... Native applications usually operate with "platform" interface elements: menus, navigation, forms and all other design elements are taken from the operating system and therefore are familiar and understandable to the user.

There is only one drawback - the high cost of development and support, also because you have to write your own code for each platform.

With the growth of the mobile app market, developers have become not only expensive, but very expensive, and native development is not something that every business owner can afford. But abandoning mobile app development in the future may cost you more. Live Typing can help you save money - describe your idea and indicate an approximate budget that you want to keep within.

And not relatives

Cross-platform applications are written for several platforms at once in one non-native language. How can such a code work on different devices? There are also two approaches here.

The first one is that at the stage of preparing an application for publication, it turns into a native one for a certain platform using a transpiler. In fact, one cross-platform programming language is "translated" into another.

The second is that a certain wrapper is added to the resulting code, which, working already on the device, on the fly broadcasts calls from the non-native code to the native functions of the system.

It is assumed that most of this code can be transferred between platforms - it is obvious that, for example, the logic of making purchases, saving an item to the basket, calculating the route for a taxi, writing a message to the messenger does not change depending on whether the client has Android or iOS. You just need to refine the UI and UX for the platforms, but now, within certain limits, even this can be combined - for example, the hamburger menu is actively used on both Android and iOS. So even making corrections to the interface so that the application meets the spirit and letter of the required platform is a matter of desire, the required speed and quality of development.

Advantages:

• cost and speed of development. Since there is much less code to write, the cost of work is also reduced;
• the ability to use the internal resources of the company. As we will show later, the development of cross-platform applications can often be done by the efforts of your existing programmers.

Disadvantages:

• non-native interface, or at least the need to work with the interface of each platform separately. Each system has its own requirements for element design and sometimes they are mutually exclusive. When developing, this must be taken into account;
• problems in the implementation of complex functions or possible problems with working even with simple procedures due to errors in the development frameworks themselves. The cross-platform environment only translates requests to system calls and interfaces into the format it understands, by the system, and therefore, at this stage, both difficulties with understanding and the occurrence of errors within the framework itself are possible;
• speed of work. Since the cross-platform environment is an "add-on" over the code (not always, but in certain situations), it has its own delays and pauses in working out user actions and displaying the results. This was especially noticeable a few years ago on smartphones that are less powerful than today, but now, with the increase in the performance of mobile devices, this can already be neglected.

As you can see, these two methods are practically mirror images of each other - that the advantages of native application development, the disadvantages of cross-platform, and vice versa.

Popular cross-platform mobile development platforms and tools

As we wrote above, there are two approaches - turning the code into native code at the build stage or adding a specific wrapper that translates calls to and from the system.

Cordova and PWA are two tools that work exactly in the ideology of the wrapper.

Cordova and HTML5

One of the most popular areas in cross-platform programming, which is often popularly called PhoneGap. In fact, a mobile site is being created, which is “wrapped” in a small platform code that translates calls from the system to the application and vice versa.

All the disadvantages and advantages are expressed here like nowhere else clearly. You can use web developers (HTML, CSS and JavaScript as the main technologies) and in a month or even a couple of weeks make the first version of the application for relatively little money. Yes, it will slow down your work, it may not have quite accurate geolocation, but it will work on all devices and will allow you, at a minimum, to test customer demand on mobile devices.

A huge number of frameworks have been created for this approach, but they all do virtually the same thing. The difference between them is that Cordova (PhoneGap) does not set restrictions and templates for logic and UI for your HTML5 project, and frameworks operate with their own ready-made UI elements that mimic mobile platforms and their own development logic. As an example of this approach, you can specify: Ionic Framework - a wrapper; Framework7, Mobile Angular UI, Sencha Touch, Kendo UI - front-end frameworks.

PWA

Fashionable technology from Google is the same web applications, but due to the use of certain technologies (first of all, these are the so-called Service Workers - scripts running in the background, and Web App Manifest - a description of a web application in a form understandable for a mobile system ) they can work as native without wrapper from PhoneGap. They can be installed on the home screen bypassing the app store, work offline, work with push notifications, with native functions.

The problem is that not all platforms even now support these "certain technologies". First of all, this concerns Apple, which, apparently, really does not like the ability to distribute applications bypassing the App Store.

Taking into account all the disadvantages of HTML5 solutions, many companies have created tools that allow you to write code in one non-native language, and then it is translated into the native one. So two birds with one stone are killed at the same time: the code base is one, and the applications are as close as possible to the native one.

Xamarin

Microsoft platform. The standard for Enterprise-development programming language C # is used, the cross-platform development environment is Visual Studio. The output is native apps for iOS, Android and Windows. True, relatively large.

React Native

Platform from - applications are written in JavaScript and using CSS-like styles. The interface turns out to be native, and the code is interpreted already on the platform, which gives it the necessary flexibility.

As a relatively young platform, React Native still obviously (though not disastrously) suffers from a lack of development tools and documentation.

Flutter

Naturally, such a giant as Google could not get around the topic of cross-platform development of Android and iOS applications. Flutter, while still only in beta, takes a different approach than React Native and Xamarin. It does not turn the source code into native code, which is executed by the platform, but in fact draws a window on the smartphone screen and draws all the elements itself. The language used is "proprietary" Dart, which Google created as an improved version of JavaScript.

This has both advantages (for example, seemingly identical interfaces) and disadvantages (for example, redrawing an interface requires a certain amount of memory and CPU time).

The platform is developing rapidly and Google is investing a lot of effort and money into it. But compared to Flutter, even React Native seems like a pretty well-established and impressive ecosystem.

What to choose

Your head is probably already spinning, but you still haven’t come up with an understanding of what to choose. Let's present a simple list of questions to help you:

• Should work somehow on any device? Choose Html as a basis;
• do you have enough funds, no rush and want the highest quality app? Take a direct path to native development;
• do you have a built-in web developer or do you just want to quickly and easily try a mobile application in action? Here you can recommend Cordova / HTML or PWA;
• do you have your own CRM system and a supporting C # developer? Take Xamarin;
• do you “want to try”, but you need to make everything beautiful and fashionable? Look away React Native or Flutter.

You can also enter from the other side. Take a look at the functionality you need in your application and proceed from this:

• a simple business card application? Take React Native or HTML5 and you get two platforms for a minimal price;
• Do you have a high traffic website and need to test the hypothesis of a presence in the mobile space? HTML5;
• complex applications with access to the desired device functions? Native Development, Xamarin, React Native.

Cross-platform development is not a panacea

When choosing, you need to proceed from the tasks set and existing resources. Cross-platform development is a good and understandable direction, but with its own advantages and disadvantages that you need to keep in mind before starting the project. The made cross-platform application is obviously better than the unmade native one. You can quickly and cheaply develop it, upload it to the store and simply check the demand from users - whether someone is looking for an application from you, whether it installs what functions it uses. Based on the results of such an experiment, it will be possible to decide the fate of the mobile direction in your company and investments in it.

Still having doubts and questions about cross-platform apps? Read about how we created an application for quickly getting a subscription to one of the city's sports facilities and try the application for paying for all kinds of services - from housing and communal services to orders in online stores. Better yet, sign up for a free consultation, indicating an approximate budget and a brief description of the idea, or contact our manager Katya by phone