2+1 Strategies for Mobile Application Development

Do you have an intent to start a mobile application project and have too many questions in your mind? Here are the five Ws of a mobile application development project:

  • What do you want to be developed?
  • Why do you want it?
  • Who will develop it?
  • Where will they develop it?
  • When will they develop it?
  • How will they develop it?

This article can help you to answer these questions and find the most suitable mobile strategy in accordance with your expectations.


Regardless of the industry or the market, customers are expecting a mobile presence from every company they interact with and every day another company faces the challenge of developing a mobile application. Mobile web or hybrid approaches may provide temporary solutions, but as we emphasized in various blog posts, your mobile presence is not compared with your competitors, it is compared with the best in class and commonly used applications like Facebook or Twitter.

Therefore, the decision is not about developing a native mobile app or not, it is about how to develop it in the most productive and suitable way for your mobile presence strategy.

There are too many things to consider:

  • Technology: Which platforms should you target? (e.g. iOS, Android, Windows Phone, Blackberry, Tizen, etc.) Which form factors should you include? (e.g. Phone, Phablet, Tablet, Wearables, etc.)
  • Project management: Average development of a single mobile app development takes approximately 18 weeks (source) and lifetime of a mobile application project is less than 2 years.
  • People management: The demand for mobile app developers expected to be saturated in 2020 (source) and the cost of a mobile developer is 1.7 times as much as a senior web developer.

Having a mobile application is not a luxury anymore, but the traditional strategies of outsourcing and platform-based in-house development still require extravagance and forgoing one thing or another:


Outsourcing mobile development projects

Receiving professional services from a third party company experienced in mobility to develop mobile apps. Way of working includes models like turnkey projects, project-based consultancy, on-premise human resource supply, etc.



  • No internal experience needed with highly experienced and well-established developers
  • No need to worry about platforms and fragmentation
  • Project management and project risk externalized
  • Faster time-to-market with experienced developers
  • More expensive on an hourly basis, change requests after project completion can be even more expensive
  • Difficult to learn and internalize mobility within the company
  • Project dependency on third parties
  • Mobile application is a living project and dependency is persistent as the lifecycle repeats
  • Reduced agility
  • Sharing company information with external parties
  • Potential communication issues with internal and external parties
  • Remote working problems with developers (e.g. enterprise systems may be inaccessible from outside)
  • Potential intellectual property (source code) issues


To avoid high costs of local resources, mobile development can also be outsourced to other countries where resources are less expensive, but this causes additional problems like culture clashes, time zone differences and quality problems.


In-house platform-based native development team

Hiring mobile (Objective-C, Swift, Java) developers, analysts and testers for each platform for development and maintenance of mobile applications.



  • Mobility can be internalized easily
  • More agility in development
  • Easier management of resources
  • Full control over development
  • Knowledge stays inside the company along with aligned interests of developers
  • No intellectual property (source code) issues


  • Expensive to hire and keep native developers and other resources separately for each platform
  • Learning cost for the company for each platform
  • Mobile application is a living project and learning the dynamics of the mobile world is a never ending process
  • Separate projects to manage, develop and test
  • Slower time-to-market especially in the first projects
  • Project dependency on people
  • High circulation rate for developers
  • Higher than average developer salaries causing conflicts with other employees
  • Especially less productive after project completion just to maintain the application for two platforms


In both cases, there are high costs associated with entering to the mobile world. These costs are either paying for the experience of outsourced developers or internal learning cost.

With Smartface, there is a third alternative, which combines the advantages of both approaches. You can quickly enter the mobile world without worrying about these costs and other disadvantages.


Cross-platform native development with Smartface

Develop native iOS and Android apps by using existing development resources with single JavaScript codebase.


(click for more details)


  • Current development team can switch to mobile just with their current knowledge
  • Low learning cost with facilitating features like drag & drop WYSIWYG design editor and Android and iOS emulators on Windows
  • Transparency from platform differences, device fragmentation and OS updates
  • Only one project to manage, develop and test
  • Faster time-to-market with single codebase and ease of use of JavaScript
  • Agility in development
  • Full control over development
  • Eliminating project dependency on people and third parties, keeping knowledge inside the company
  • Project maintenance is more productive with shared resources with frontend/backend developers. Same person can develop the same project for web and mobile channels.
  • Plug-in support for easy reuse of development packages
  • Built-in enterprise plug-ins
  • No intellectual property (source code) issues
  • Dependency on a platform
  • Perpetual license fees
  • Some niche features of platforms not built-in
  • Potential resistance to a new tool from current iOS and Android native developer team


Dependency on Smartface may seem a disadvantage, but it is an advantage as well. You do not need to worry about different devices types, platforms, OS updates, etc. Smartface creates a transparent layer for you and takes care of such complications within the framework.


Consider iOS and Android version and fragmentation for a mobile strategy

iOS and Android version and fragmentation timeline


Just keep your project upgraded to the latest version of Smartface and you are all set and if you do not want to develop everything with Smartface, you can always use Java/Objective-C/Swift codes in your Smartface application with the plug-in support.

Moreover, Smartface reduces dependency on people and the knowledge is kept inside the company. With features and components designed for the specific needs of enterprises, you can easily build fully integrated company-wide systems, allowing the standardization of processes and enhancing them with mobility.


Therefore, we recommend you to choose your mobile strategy wisely and consider all factors such as

Download Smartface now and start developing your apps right now free, without dealing with a third party developer or worrying about hiring a new developer.

How to Increase Productivity and Reduce Costs in Native iOS and Android Development with Smartface

The demand for mobile applications is increasing at a high rate and the demand for mobile developers is increasing in parallel. According to various sources as well as our discussions within the industry, this demand exceeds the supply by a large margin. For employers, this means additional effort and cost towards hiring and employee retention.

What’s more is that, for a platform-based native mobile development project for iOS and Android, you need at least four people:

  • An iOS developer
  • An Android developer
  • A Project manager to coordinate two separate mobile projects
  • A Software tester to test two separate mobile projects.

Similarly, if you are a web developer and want to switch to developing iOS and Android apps, you need to learn two different languages along with the accompanying mobile standards: Java for Android and Objective-C/Swift for iOS. The learning cost is high and you need to develop two projects from scratch.

iOS and Android version and fragmentation timeline

iOS and Android version and fragmentation timeline

As you can see from the timeline above; device, version and architecture fragmentation is becoming a more serious issue for both Android and iOS. Therefore, besides separated projects for platforms, you may need to have sub-projects for different architectures or screen sizes, which brings additional

The solution is to use cross-platform development, but choosing the right cross-platform solution requires care since native app experience cannot be foregone that easily. What if we tell you that there is a best of both worlds solution for your native application development worries?

With Smartface, you don’t need to sacrifice native quality and you can still be more productive than platform-based native development.

We did the math for you: For native development with and without Smartface for a average sized mobile application project, you need the following resources with the following yearly costs (source: payscale.com):

Native development with Java/Obj-C/Swift Native development with Smartface
Number of projects 2 separate projects for the same application (iOS and Android) 1 cross-platform application project for iOS and Android
Project duration 8 weeks 5 weeks (Smartface advantage)
Development resources & yearly salaries 1 iOS Developer (3 yrs exp) – $105k/yr
1 Android Developer (3 yrs exp) – $102k/yr
1 JavaScript Developer (3 yrs exp) – $74k/yr
Management resources 1 Project Manager (5 yrs exp) – $95k/yr 0.5 Project Manager (5 yrs exp) – $95k/yr
Testing resources 1 Software Tester (3 yrs exp) -$65k/yr 0.5 Software Tester (3 yrs exp) – $65k/yr
Total project cost
$122k $32k


In this example, the productivity is around 4 times. As the projects get more complicated, Smartface provides even more productivity with the Android and iOS emulators on Windows as well as the WYSIWYG application design editor.

Moreover, you don’t need to worry about updates or new devices, Smartface takes care of it all.

Smartface isolates you from the complexities of fragmented world of mobility. Just develop your app with a single JavaScript codebase and run your native app on any device.

If you want to reduce costs and increase productivity for native mobile app development for iOS and Android, Smartface offers you a best-in-class solution. Start developing more apps with less cost, right now! Download Smartface App Studio for free.

Apple Pay: How does it work and how is it different from Google Wallet and other NFC-based m-wallets/mobile payment systems?

In our series of mobile landscape articles, such as App Security Tips, we will be discussing Apple Pay today. How does it work and why is it different from Google Wallet and other NFC-based m-wallets/mobile payment systems?


First of all, some background information about NFC payments:

  • For security purposes, a method called tokenization is used in NFC payments.
  • Instead of the card information, everything is done with a secure token generated per device.
  • The de-tokenization (translation to payment information) is done at the upper levels of the payment chain, either at the bank or payment network level so none of the intermediaries has any information about the card or the card owner.
  • However, the token itself still needs to be secured and NFC standards require the use of a “secure element” inside the device. This can be established on a chip on the device or on an external element like a SIM card or a cloud-based solution as long as it is encrypted and protected from tampering.

Payment process can be divided into three steps:

  • To make a payment, the user gets authenticated with the payment device in the first step.
  • Then the NFC reader communicates with the “secure element” of this device.
  • As the final step, token is sent along with accompanying information.

NFC payments flow in Android devices


This is where Google Wallet and Apple Pay differs.

As Google does not have the full control over the hardware, it needed to rely on network operators to use the secure element. However, network operators in the US was offering a competing payment product (formerly ISIS, now known as Softcard), so they disallowed Google’s use of secure element.

To overcome this limitation, Google started supporting software based secure element solutions (Host Card Emulation, HCE in short) with Android 4.4, but with the current fragmentation of Android devices, this is not expected to jumpstart the use of Google Wallet in the short term.

Taking lessons from the problems surrounding Google Wallet, Apple positions itself in a different spot than other payment providers.

  • Unlike Google Wallet or PayPal, Apple Pay itself is not a fully-fledged payment platform.
  • Apple just converts your physical wallet to a digital one; the customers still rely on other financial institutions.
  • Therefore, Apple is not considered as a competitor and can cooperate/co-exist with other players. (Yes, Apple took the blessing of the network operators who opposed Google Wallet.)

Moreover, the advantage of Apple’s insistence on a closed hardware ecosystem shows itself here. As the sole provider of hardware, Apple provides its own secure element in iPhone 6, iPhone 6 Plus and Apple Watch, so if the things go sideways, Apple is not dependent on third parties for the secure element and Apple already has full control of the operating system, iOS 8.


Both Apple’s and Google’s approaches come with certain advantages and disadvantages.

For Apple Pay to accept different credit cards, Apple must deal one-by-one with all parties in the payment ecosystem:

  • Issuers (banks)
  • Credit card networks
  • Payment intermediaries
  • Processors
  • Merchants

Even though Apple can provide novel ways to overcome the inconveniences of the currently available solutions, it will take time to negotiate with all stakeholders for the widespread use of Apple Pay, especially outside the US. Apple Pay is not expected to launch in Europe sometime in 2015 and maybe even later for the rest of the world. On the other hand, Google deals with this issue in the backend and can unify all credit cards into one.


For Apple, this is translated to an advantage by simplifying the payment method addition process:

  • Users take a photo of their “supported” cards,
  • The card is automatically converted into a token,
  • It can instantly be used for payment because Apple deals with issuers directly.

For Google however:

  • The users enter their card information manually into Google Wallet app/website
  • When they use NFC, they actually pay with the Google Wallet card, not their own credit card
  • Google charges it back to the actual card.

It may not matter for users that much, but it is a complex process for Google as repeated layers of processing is required. Google must take the roles of an issuer, processor and other intermediaries just for a simple transaction, which makes it a direct competitor.

An additional effect of Apple’s approach is that there is no need to store transaction information and the transaction can be viewed like a regular one on the statement of the credit card. Apple emphasizes this as a security feature, but it is a bit subjective, as people may prefer to have a record of their mobile transactions in one place as Google Wallet offers.

The real difference of Apple Pay from other payment solutions comes in play at the actual payment stage:

  • For Google Wallet, the user must launch the app first and then enter their PIN to pay.
  • Being the sole provider of hardware, software and the payment platform, Apple eliminates the middle steps. Once the device is near the NFC reader, the user just authenticates by using Touch ID, without any apps or PINs.

In summary, it comes down to a comparison similar to iOS and Android:

  • Apple Pay focuses on design and ease of use
  • Google Wallet focuses on convenience and flexibility

Apple is not the first entrant in the market, but it has the power to disrupt it. Yet, for the reasons specified, both Google Wallet and Apple Pay may have a hard time getting widely adopted.

Last but not the least, while everybody is paying attention to the long-awaited contactless payment feature, Apple silently took another step to control everything inside the Apple ecosystem. With new Apple Pay APIs, payments from mobile apps and from iTunes can be done with Apple Pay.


Physical payments may be the luring factor but it is not the single objective in the grand scheme of things, especially considering the fact that Apple prefers to have control over everything. Now, Apple has the access to real life in-app transactions such as commodity (e.g. Target) or service (e.g. Uber) transactions. Considering the total size of such transactions on a global scale, physical payments would just be icing on the cake.

One thing to note is that Apple Pay still requires developers to work with a payment provider and the developers must use Apple Pay SDK along with the provider’s SDK, making Apple Pay seem not a competitor but a facilitator instead.

However, the competition is already heating up as Apple disallows the use of NFC chip for anything else than Apple Pay and PayPal is not one of the initial payment provider partners of Apple.

Everything aside, time will tell if Apple Pay will become another Apple service present for the sake of confinement like Apple Maps, or a mandatory-ish service like iCloud or naturally adopted service like Siri.

Download Smartface now and keep yourself up to date with the latest developments in the mobile landscape.

Smartface vs. Xamarin (Cross-Platform Native Frameworks)

The objective of Smartface is to make native app development accessible to masses without sacrificing quality. At every opportunity, we emphasize the importance of “real native” quality and performance and that makes “real natives” win over “like-native” hybrid frameworks like Phonegap, Cordova, etc.

Unlike hybrid frameworks, most of which are just the fork of a single product, huge amount of effort is required to create cross-platform native frameworks. Therefore, there are only a handful of cross-platform frameworks that produce real native output.

While all cross-platform native products are praiseworthy, Smartface is here to make cross-platform native development even more appealing along with end-to-end lifecycle management.

In this article, we would like to explain you the main differences between Smartface and Xamarin (Microsoft).

Smartface Xamarin (Microsoft)
Mobile Application Development
Technology/Scope Cross-platform native Cross-platform native
Look and Feel, Sense, UX Native Native
UI Responsiveness Smooth Smooth
Performance Fast Fast
Development Language JavaScript (ECMAScript 6) C# (Microsoft lock-in)
Single Codebase Yes Yes (Xamarin.Forms only)
Supported Platform iOS and Android Native iOS, Android & Windows Native
100% iOS & Android

Native API Access

Yes Yes
Advanced Native Platform Support No (through plugins) watchOS, tvOS, Android Wear, Game Development & macOS (not single codebase)
Development Environment Cloud-based Desktop-based
WYSIWYG Design Editor Yes No – Xamarin.Forms (previewer),

Yes – non-single codebase Xamarin.iOS and Android

Real-time Development Collaboration Yes No
Wireless Deployment and Instant Update to Real Devices Yes Yes (in alpha phase, some app features are not supported)
Debugging Yes (Android-only) Yes
iOS Application Development and Signing without a Mac Yes Partially (only for development certificates, not for distribution)
Works on any Environment and OS without any Setup Yes No
Extend with Plugins Yes Yes


Smartface Xamarin (Microsoft)
Mobile Application Lifecycle
Integrated Cloud Environment for App Lifecycle Yes Partially
Update Native Apps Skipping App Store Submission (Hot Deployment) Yes No
Testing Distribution Yes Yes
Testing Automation for

Device Farms

With 3rd party tools Yes
Next Generation No-Ops Approach Yes (All modules are fully integrated, no need for configuration and CLI) No
Crash Analytics and Bug Reporting With 3rd party tool

(integrated with Fabric.io)

Enrollment-free Enterprise App Store Yes No (MDM tool available)
Build for and Submit to App Stores without a Mac Yes No
Single-Link Distribution for Store Apps Yes No


Xamarin offers a different approach to cross-platform native development compared to Smartface. It is C# based and unlike JavaScript based Smartface apps, whose code are interpreted at runtime, Xamarin apps are complied.

Therefore, besides the cloud-based next generation development and lifecycle management environment offered by Smartface,  primary differences between Smartface and Xamarin stem from the differences between C# programming and JavaScript programming.

Although it would not be possible and appropriate to classify one language being superior to the other; the types of developers can be classified as backend-oriented for C# and frontend-oriented for JavaScript due to the nature of the languages (JavaScript is also preferred for C# applications with a web frontend). Since user experience is of the highest importance in mobile development, developers with more frontend experience may produce better results and get acquainted to mobile development faster.

Both frameworks produce native output for iOS and Android. Yet, because of compiler and interpreter differences, binary sizes are smaller in Xamarin for small projects, but as the projects get larger, the interpreter overhead in Smartface eliminates repetition and binary sizes are smaller in Smartface for larger projects. A related advantage of interpreter structure of Smartface is that it is possible to run JavaScript files from the server. Therefore, app updates can be applied without submitting a new version of the app to the stores. A similar feature is available in hybrid apps, but they are just webpages. Smartface allows this for native apps and this is not possible for platform-based native apps and Xamarin.

Another thing to note is that until recently, Xamarin did not have a single code based offering. It was required to code separately for each platform. For standard Xamarin projects, this is still the case, but there is an offering called Xamarin.Forms, which allows single code based apps for a specified set of UI controls.

Both platforms have their own IDEs. The advantage of Xamarin is that besides its own Xamarin Studio, it has Visual Studio support and this is an important advantage for target audience of C# developers. However, this still requires a serious installation and update effort.

With Smartface, you can start mobile development instantly without any setup, just in your browser, fully independent from platforms.

Smartface also has a single codebase WYSIWYG (What You See Is What You Get) design editor with full source code generation. In Xamarin.Forms, the single codebase offering, there is only a design previewer, which requires XAML for UI development.

In Smartface, you may choose to design your app either with drag and drop components, with code or with a combination of both. Smartface design editor produces actualy JavaScript, not an intermediary XML code such as XAML. Xamarin has platform-specific “designer” tools for visual design of apps, but it is not directly translated into working apps. In Smartface, your design appears on any phone/tablet as exactly as you see it on the visual editor.

Moreover, Xamarin does not support iOS development on Windows (or Linux for that matter). If you have a Mac in the same network, you can use Windows to develop iOS apps in Xamarin, but it does not eliminate the need for a Mac and setup over network may be an issue in some network configurations. Smartface is the only cross-platform native framework that supports whole iOS development cycle on Windows.

Moreover, C# is not as common as JavaScript and might introduce a dependency on a specific ecosystem. For developing with Smartface, web know-how is sufficient, so the potential community is much larger.

Both platforms are highly stable. Smartface is a next generation cross-platform native framework developed for enterprises with enterprises and it is almost as stable as the platform-based native frameworks themselves.


From an enterprise perspective, development is only one part of the mobile application lifecycle. Since Xamarin has been developed from a community perspective until Microsoft acquisition, it is still in a transition phase to a full enterprise focus. On the other hand, Smartface has been developed for enterprises in mind.

In terms of mobile application lifecycle management, both platforms offer comprehensive tools, however Microsoft’s lifecycle management offerings are brought together by combining different tools and not built with integration in mind from scratch. For this reason, the environments are not fully integrated and depends on a CLI tool for some workflows.

Smartface has a fully integrated and seamless lifecycle management environment in the cloud. There are no upload or download operations for application binaries from development to store deployment. This brings in high productivity.

Tools provided by Microsoft are focusing on automating certain parts of the DevOps processes; whereas Smartface as a whole focuses beyond DevOps, to a “No-Ops” approach where no setup or intervention is required from development to distribution.


And the last but not the least is that Microsoft doesn’t have an enrollment-free enterprise app store, meaning that MDM required for in-house app distribution, which is not viable especially in B2B or BYOD (bring your own device) use cases. Smartface Enterprise App Store does not require an MDM solution and can be used instantly from the cloud.

Xcode for Windows with Smartface for Native iOS Development

As the demand for iPhone and iPad apps is increasing every day, more people want to use Xcode to develop mobile apps for iOS. However, Xcode requires Mac OS and MacBooks, iMacs and other Macs are not that affordable compared to Windows PCs.

Therefore, Xcode for Windows is desirable to develop apps with Swift or Objective-C on Windows. There are some unofficial and unsupported ways to run Mac OS on PC. Please note that Smartface does not endorse such practices and they are available only for information purposes.

The first one is “hackintosh” approach, which means running Mac OS on non-Apple x86/x64 PCs by using custom kernels, kexts (drivers) and EFI bootloaders like Chameleon or Clover to load Mac OS on a Windows PC. The second approach for Mac on PC is to use virtual machines like VirtualBox or Vmware Workstation. You can run a Mac OS virtual machine.

Both approaches require a great deal of technical effort and there may be compatibility or performance issues. For instance, your graphics card or wireless adapter may lack a kext and you may be required to run your hackintosh with a low-performace generic graphics kext or without a network connection. Especially iOS simulator of Xcode may be troublesome to run.

If you are not an advanced user, this approach is not recommended just for iOS development on Windows. Moreover, Apple forbids running Mac OS on non-Apple hardware and the approaches described are directly against Apple software license.

Smartface offers a legitimate and easy solution for your Xcode for Windows worries and even offers features that are not available in Xcode.

You cannot develop native Android applications with Xcode using Java, but with Smartface, you can develop iOS and Android applications with a single JavaScript codebase. Xcode requires the use of Swift or Objective-C for iOS development, but with Smartface, you can use JavaScript for native apps.

Therefore, Smartface is like Xcode on Windows for iOS and Android development. It has a drag and drop WYSIWYG editor that is as easy as Xcode and an on-device iOS emulator on Windows just like the iOS simulator on Xcode. Both iPad and iPhone emulation can be done on Windows with a phone or tablet connected to your PC similar to Xcode on-device simulator. iOS debugging on Windows is fully supported as well, so you can test your iOS apps on Windows.

iOS Emulator for Xcode on Windows with Smartface

Smartface Android and iOS emulator is just like Xcode for Windows

The only point where you will require a Mac will be for the App Store submission, which takes only a couple of minutes. Due to Apple’s license restrictions, you need to sign your app on a Mac, for which you can rent a virtual Mac from the cloud for a few minutes or borrow a friend’s Mac.

Xcode may have some additional features that are still under development for Smartface, but unless Apple changes its strategy, Smartface is the one and only solution for native iOS development on Windows.

Download Smartface App Studio and start developing Android and iOS apps on Windows right now.

Smartface App Studio vs. Appcelerator Titanium (JavaScript Based Cross-Platform Native Frameworks)

The objective of Smartface is to make native app development accessible to masses without sacrificing quality. At every opportunity, we emphasize the importance of “real native” quality and performance and that makes “real natives” win over “like-native” hybrid frameworks like Phonegap, Cordova, etc.

Unlike hybrid frameworks, most of which are just the fork of a single product, huge amount of effort is required to create cross-platform native frameworks. Therefore, there are only a handful of cross-platform frameworks that produce real native output.

While all cross-platform native products are praiseworthy, Smartface is here to make cross-platform native development even more appealing and in this article, we would like to explain you the main differences between Smartface and Appcelerator Titanium. You can also view our comparison with Xamarin.

Platform Based Native Appcelerator Titanium Smartface App Studio
Output Native Native Native
Development Environment Xcode, Eclipse Titanium Studio Smartface IDE
WYSIWYG Design Editor iOS: Yes,
Android: Partially
No Yes
Code Based Design Editor Yes Yes Yes
iOS Development on Windows No No Yes
Single Code Base No Yes (More platform-specific code required) Yes
Supported Platform iOS or Android Cross-platform: iOS, Android, Windows Phone Cross-platform: iOS, Android
Development Language Objective-C, Swift, Java JavaScript JavaScript
Adaptation Mobile know-how Web know-how Web know-how
Look and Feel, Sense, UX Native Native Native
UI Responsiveness Smooth Smooth Smooth
Performance Fastest Faster Faster
Extend with custom plug-ins Yes Yes on Roadmap
Community Largest Large Medium
Technical Support Community Community &Expensive enterprise package required for direct support [1] Community & Inexpensive license packages sufficient for direct support [2]
Stability Highest Medium Higher
Security Most secure Secure Most secure (also includes advanced features)
Risk Learning Cost, Operational Cost Dependency, Expensive licenses after free version [1] Dependency

[1] As indicated in Gartner’s Magic Quadrant for Mobile Application Development Platforms 2014

[2] Ticket support is included starting from medium-level Smartface Commercial license


In many ways, Smartface and Titanium are similar. They are both JavaScript based and they both produce native output for iOS and Android. Titanium can also produce Windows Phone 8 output, but it does not support Windows Phone 8.1 yet, making its scope rather limited.

One thing to note is that Smartface unifies platform-specific components as much as possible, but Titanium opts for some level of separation; therefore, there may be a bit more platform-specific coding in Titanium than Smartface.

Both platforms have their own IDEs. Titanium Studio is based on Eclipse and developers may be more familiar with it, however application design is difficult in Titanium.

Smartface is the only cross-platform native framework with a WYSIWYG (What You See Is What You Get) design editor. In Titanium, you are forced to code your user interface, if you’re not an enterprise customer, but in Smartface, you may choose to design your app either with drag and drop components, with code or with a combination of both. In Smartface, your design appears on any phone/tablet as exactly as you see it on the visual editor.

Moreover, Titanium does not support iOS development on Windows nor iOS emulator or debugger. If you want to develop cross-platform apps on Titanium, there is no other alternative than using a Mac. Again, Smartface is the only cross-platform native framework that supports whole iOS development cycle on Windows.

One advantage of Titanium is the support for plug-ins to extend you project with native code. This feature will be available in Smartface in late January 2015.

Even though the most notable advantage of Titanium over Smartface may seem to be the size of the community, the same thing cannot be said for user satisfaction. Community comments indicate that there are still stability issues with Titanium. [Sources: Stack Overflow and Appcelerator Community]

However, Smartface cross-platform native framework was developed in closed beta for a long time before making sure that it is almost as stable as the platform-based native frameworks themselves.

Of course, community satisfaction is not just about stability. Titanium does not provide any direct support unless you pay a huge amount for the enterprise license. In Titanium, you start with the free package, but if you want to do more, you hit a wall. You need to purchase an expensive “Appcelerator” product. [Source: Gartner]

Yet, in Smartface, you can start with the free package that have no limitations whatsoever and you can upgrade to inexpensive packages for direct support.

Therefore, while choosing a cross-platform native framework, we recommend you to consider not just the popularity of the framework, but the capabilities and support offerings as well. We suggest that, with the features that are not available in other frameworks, Smartface is the better choice.

You can check Smartface App Studio benefits and download it free.

How to Develop and Market Great Apps from Great Ideas

You have a great idea for a mobile app; do you know how you can convert this idea into reality as well as share your creation with the world? It’s as easy as pie:

  • Analyze your idea and decide what kind of an app you can develop
  • Download Smartface App Studio for free
  • Develop and design your app for iOS and Android.
  • Publish ready-to-market apps with one click
  • Submit your app to Apple App Store and Google Play
  • Sign-up for Mobile Action for free
  • Optimize your app in the App Store and Google Play
  • Boost your app’s visibility and let everyone know about your app

Smartface App Studio is a one-of-a-kind cross-platform mobility framework that offers a WYSIWYG design editor and a JavaScript development environment to publish native apps for iOS and Android. Moreover, it’s the only environment that supports the whole iOS development process on Windows. You can build high quality mobile apps, easily.

Now that you’ve built your app with Smartface App Studio, what’s next? Market your app and make it visible in the App Store.


Apple App Store and Google Play are great to reach millions of people, but publishing an app doesn’t guarantee a good ranking. To get your app discovered, boost your organic downloads and drive revenue, you need to consistently optimize it within the App Store and keep an eye on your competition. Mobile Action’s free self-serve App Store intelligent, insight and optimization tool is the most cost effective way to solve this problem. It gives you all the important data about your app and your competitors to get your app ahead in the App Store — all for free.

With facilitators like Mobile Action and Smartface, you don’t need to restrict yourself with thoughts like “how can I develop easily”, “how can I show off my app in the App Store”, etc. Let your creativity run free; develop any app you want and acquire users easily.

How to monetize your apps and earn money from Smartface apps with AdMob and In-App Purchases

As the name implies, AdMob is a mobile advertising platform owned by Google. There are many mobile advertising networks such as Apple’s iAd or Facebook ads, but their market share is limited compared to AdMob.

AdMob’s is a cross-platform environment just like Smartface, it offers advertising for all mobile platforms including iOS, Android and Windows Phone. What’s more is that AdMob is connected both with Google’s desktop advertising platform AdSense and ad serving platform AdWords. Therefore, with a single account, you can manage all your earnings from different sources.

To use AdMob in your mobile apps, you need to register with Google for free and then install its SDK, but with Smartface, you don’t need to bother with installing and updating AdMob SDK. Smartface App Studio already has AdMob SDK built-in for both iOS and Android. After creating a suitable ad unit in AdMob control panel, you can follow the instructions in the “Implementing AdMob” article to add advertisements to your app.

Then you are ready to earn money whenever users view or click the ads in your mobile application. Your payments are made automatically to your specified bank account. Moreover, you can track the performance of the ads with detailed analytics and adjust you ad placement in your app. Here is a final motivation for you, the Flappy Bird app is said to earn $50K per day just from ads.

Alternatively, “freemium” model is very popular these days, you can offer your app for free and then you can use in-app purchases (IAP) to monetize your app. It is very easy to implement in-app purchases with Smartface in a cross-platform way. For implementing in-app purchases to your apps, please refer to our API documents.

With Smartface, you can develop cross-platform native iOS and Android apps with high productivity and low costs. Even with the free community version, there are no limits for using AdMob or in-app purchases; you can make a profit with zero investment.

Start developing profitable mobile apps right now by downloading Smartface.

Smartface App Studio vs. PhoneGap/Sencha/Cordova (Cross-Platform Native vs. Hybrid Environments)


In today’s all-accessible world, your customers are not comparing your app with just another random app. In terms of user experience and design, you are competing with the likes of Facebook, Twitter, LinkedIn and Tinder.

We think that end-users and some of the developers are confused about platform based native (Smartface App Studio) vs. hybrid (PhoneGap/Sencha/Cordova) mobile development frameworks. We would like to explain you the differences between various types of development environments.

Hybrid and cross-platform native environments may sound similar at a first glance, but there are many critical differences in terms of the output. Smartface and PhoneGap provide completely different approaches to mobile development.

Platform Based Native PhoneGap / Cordova Smartface App Studio
Output Native Hybrid Native
Development Environment Xcode, Eclipse Jetbrain Webstorm, Sublime Text, Intel XDK, Eclipse Smartface IDE
Mac Required for iOS Testing and Debugging Yes Yes No
Single Code Base No Yes Yes
Supported Platform iOS or Android Cross-platform Cross-platform
Development Language Objective-C, Java HTML5/JavaScript/CSS JavaScript
Adaptation Mobile know-how Web know-how Web know-how
Look and Feel, Sense, UX Native Native-like Native
UI Responsiveness Smooth Not smooth Smooth
Performance Fastest Fast Enough Faster
Device Sensors Yes Needs plug-in Yes
Offline Storage Device storage Limited device storage and shared web storage Device Storage
Connectivity Online and offline usage Online and offline usage Online and offline usage
Security Most secure Depends on tech Most secure
Device Specific Features Yes Depends on tech Yes
Risk Learning Cost, Operational Cost Handling Browser Compatibility issues Dependency

Hybrid platforms like PhoneGap/Cordoba are mostly web-based, only their containers are native, so the development approach and the end products are very similar to web pages/web apps. Therefore, hybrid apps usually struggle to establish the smooth and slick usability of native apps. You can develop and deploy your hybrid app to multiple platforms easily but the app would not carry the feeling of being “at home” in any platform.

The only advantage of using a hybrid app over a web app is to get access to most commonly used device features such as camera or contacts. However, access to advanced device features or interaction with other apps requires native development, which completely eliminates the advantage of hybrid platforms.

On the other hand, cross-platform native environments such as Smartface provide real native output and native access to device functions by utilizing the same level of JavaScript knowledge required to develop apps on PhoneGap. The only disadvantage of such development environments is the number of supported platforms. Smartface supports iOS and Android and they cover more than 90% of the mobile OS market.

Moreover, Smartface App Studio already contains webviews. Therefore, if you want to develop HTML 5 based apps, you can still use Smartface and have a better development experience in terms of native function access and user support. Hybrid environments like PhoneGap are not exactly comparable with native environments like Smartface. PhoneGap contains only a subset of functionalities available in Smartface.

Hybrid (PhoneGap/Cordova) environments may seem appealing for starters but eventually, the limitations start to annoy developers and there are many cases of costly shifts from hybrid to native or cross-platform native (Smartface App Studio).

The chosen approach could vary according to project needs and company strategies. We suggest that for the companies that the productivity matter most, Smartface is the better choice over PhoneGap.

You can check Smartface App Studio benefits and download it free

@smartface_io team

iOS 8 Jailbreak

iOS 8 Jailbreak Released

Everybody is talking about how to jailbreak iOS 8 these days. Do you know what it means in technical terms and how you can detect jailbroken devices with Smartface App Studio?

What is iOS 8 Jailbreak?

iOS Jailbreaking is the process of obtaining root access (superuser – su or admin access) on iOS devices. Apple keeps all devices “jailed” with a locked bootloader and system for their security reasons. Breaking this security requires exploits/bugs to find a way around restrictions. Even this is a legal operation, it voids device’s warranty.

There are two jailbreak methods. Tethered jailbreak, requires a connection to computer at every boot/loading session on iOS devices. Untethered jailbreak doesn’t require a computer connection for every loading. Currently all iOS versions up to 8.1 can be jailbroken.

Why do you need to jailbreak iOS?

There are many reasons to jailbreak an iPhone/iPad: Customizing the device with keyboard gestures, system colors, animation speeds, etc; accessing forbidden apps by Apple (for example; game console emulators, system level file managers) and mostly beacuse to install pirated (cracked) apps with iOS jailbreak. Jailbroken iOS users also get some new functionalities such as new notifications center and folder structures before offically announced by Apple.

iOS 8 Jailbreak

iOS 8 Jailbreak

What is Cydia?

Cydia is the most popular app installer and marketplace aggregator for jailbroken devices. It enables installation of jailbroken apps from different “repositories”.

For expert users, root level access may be desirable, but if you are not sure what you are doing, jailbreaking makes your iPhone or iPad vulnerable to malicious activity. Also it’s proven that some of the jailbreak tools have some evil code that turns iOS devices into zombies. If you want to make your app more secure, don’t worry. You can check Security Tips for Smartface App Studio Development.

You can detect if a device is jailbroken and prompt the user to take actions against malware with some tools. When you detect a jailbroken device before the app launch, you can display a disclaimer that this app running on an insecure device. This will also relieve you from any damages in future.

Detecting Jailbroken iOS 8 devices with Smartface

Detecting jailbroken devices while developing your app with Smartface App Studio is easy. Like always…

Detecting device modifications on Smartface App Studio can be done with a single line of code below:

You can refer to Device.modifiedOS Property for more information:

if (Device.modifiedOS) { //will return true for Jailbroken or Rooted devices
alert(“Your device operating system has been modified“);

Moreover, with Smartface, you don’t need to jailbreak your device to develop your apps on Windows PCs. Our Windows based development environment handles it all without breaking any restrictions. You can download Smartface App Studio here.