10 Tips for Remote Working for Software Development Teams (whether on a Daily Basis or in a State of Emergency)

/in , , /by

As the COVID-19 or widely known as the Coronavirus is spreading around the world, more and more companies of any size and industry have no choice but to have their employees work remotely and preferably from home, sometimes even mandated by the governments themselves.

Compared to the state institutions or the manufacturing industry per se, the tech industry looks better equipped and more acquainted with remote working; but things are not as they seem. Especially in software development, the teamwork and collaboration are so crucial that many teams are specifically conceived for working together onsite.

Although the new generation of collaboration tools are working to alleviate the burden on physical presence, the core tools of software engineers have not yet caught up except a few innovative collaborative coding tools.

There are many technology start-ups as well as enterprises who successfully maintain a work from home culture with multi-location teams across geographies and even different time zones. Here are some tips as a guide to a successful telecommuting for software development teams, regardless of their technology stack.

 

1. Embrace the cultural shift

The current state of things regarding the virus outbreak is indeed unpleasant and the safety and the wellbeing of the employees overweighs any biases or concerns regarding remote working.

Even under normal circumstances, remote working has a positive impact on the wellbeing of the employees, which are usually overlooked.

Of course, the shift does not happen just with the employees. The working environment is as crucial, so it also requires a shift in the technologies being used. In this sense, this is also an as an opportunity to realize the actual benefits of working in the cloud. Assess if and how you can shift the working environment to the cloud with the next generation solutions.

 

2. Overcome the negative bias about remote employees

There is a bias the employees will work less efficiently remotely. In certain industries such as manufacturing, that may be more applicable, but in the tech industry, the employees can be as productive as onsite with the right tools.

Remote presence tools such as chat and videoconferencing has been evolving for remote work from the cloud and now it is time for the core tools to follow.

Smartface Cloud IDE is one of the first of its kind to provide a full-featured Cloud IDE for mobile development and any other compatible technology stack such as JavaScript, TypeScript, Java, and .NET. It is not just a “browser-based editor”, but instead a cloud-powered development environment that employees can use remotely just as they would onsite.

 

3. Set up a platform-agnostic work environment

Due to the current circumstances, many enterprises are being obliged to take emergency actions to mandate working from home. However, the employees may be constrained with infrastructure limitations.

For instance, even if the employees are allowed to use their personal devices at home for work, their devices may be unsuitable due to the hardware or the software. (e.g. iOS development requires a Mac no matter what.)

The next generation cloud tools like the Smartface Platform aim to eliminate this dependency. Smartface Cloud IDE and Smartface Cloud CI/CD platform are fully independent from hardware and software. You can develop, build and deploy mobile apps anywhere and it works fine on low-end hardware as well.

Another benefit is the reduced battery consumption for the remote client. As the heavy lifting is offloaded to the cloud, the client consumes much less resources just to run the web browser instead of a heavy set of processes for an IDE.

Mobile development has one additional concern of running apps on mobile devices. When working onsite, the employees can utilize a common device pool, but working remotely requires an alternative solution to run mobile apps on multiple devices.

For this reason, we developed Smartface Preview on Device module. You can test your mobile apps just in your browser on multiple devices, no downloads or installation needed.

 

4. Utilize highly available and scalable solutions

Many enterprises provide ways of accessing the internal resources usually through the combination of VPN and remote desktop. However, both of these technologies have significant scaling challenges if the enterprises haven’t invested sufficiently on the infrastructure.

Remote desktop requires a steady and high bandwidth connection and even the slightest delay has a highly negative impact on the experience. When combined with VPN, the problem may be  augmented, since a high-performance VPN requires a high capacity network infrastructure. In cases where all employees are working remotely just as we are facing now, the combination of VPN and remote desktop may not be up to the task.

Even if the VPN infrastructure is sufficient, there are challenges in configuration of the local clients and certain experience issues while taking over the full network traffic of the client.

Smartface Cloud IDE provides a much better experience than a remote desktop solution, with less dependency on the network stability and less bandwidth requirements. Moreover, the VPN can be handled on the server-side, putting less strain on the network.

Smartface Cloud IDE is a cloud-native solution and with its Kubernetes-based structure, it is highly scalable and available. All employees can work remotely with the same performance they can expect onsite.

 

5. Utilize collaborative solutions

Nowadays, most enterprises are using either Google Gsuite or Microsoft Office 365 for enterprise collaboration. For software development teams, tools like Atlassian JIRA and Slack are also following suit.

With remote working getting more prominent, these suites are getting more indispensable to remote access to resources as well as sharing and collaboration.

Smartface Cloud IDE enables enterprises to realize the benefits of the cloud collaboration for coding. Just like a Google Doc, developers can share their workspaces with others and work on the same project as if they are next to each other.

 

6. Implement strict guidelines and a structure

Another challenge of remote working is standardization. Especially, if the employees are using their own devices, it is highly problematic to manage a wide range of points from licenses to tooling standards.

Smartface Cloud IDE overcomes these issues with the pre-configured workspaces built for the enterprise specifications. The Cloud IDE can be used for many different technology stacks, including but not limited to JavaScript, Java and .NET.

The enterprise can prepare a specific workspace image and the all employees will have the exact same workspace when they load the Cloud IDE, regardless from where they access it.

 

7. Don’t let the tooling limit the flexibility

One thing that employees struggle when working from home is their personal setup if they are working on different devices. This may cause a loss in productivity from different aspects.

Smartface Cloud IDE provides the best of both worlds for this purpose. The developers can access the same environment just as they left it from any device. This minimizes the adaptation time and ensures that the developers are in their comfort zones where they are the most productive.

While Smartface Cloud IDE comes with pre-configured workspaces for the convenience of the enterprise, the IDE itself is fully customizable for the convenience of the developer. It is a full-featured IDE that matches desktop IDEs with features and experience.

 

8. Eliminate the pressure of demonstration of work

When working remotely, there is usually an untold pressure for the need to demonstrate that the employee is indeed working. Similarly, the supervisor is also concerned if the employee goes silent for a while.

Even the thought of this pressure distracts employees and reduces productivity. It is further intensified when the employees start focusing on “showing off work” instead of doing the actual work.

Smartface Cloud eliminates these concerns by providing various usage reports based on the Cloud IDE and CI/CD activities. The developers can focus on their work and the work shows itself with detailed reports.

 

9. Monitor, review and improve

Monitoring the productivity is not only crucial for the supervisors, but it is also important for establishing the remote work culture within the enterprise. The productivity numbers will help you see if there are any improvement areas to increase the productivity.

Smartface Cloud IDE reporting and auditing tools helps you make improvement decisions backed with numbers and if these decisions are related with technical improvements and changes, you can simply deploy a new IDE image and the updated IDE image will be available for everyone when they next launch their environment.

 

10. Realize the benefits and make the changes permanent

Whether through the circumstances or through a deliberate choice, you will have worked your way through the challenges of remote working with the help of best-in-class solutions like the Smartface Platform and you will be realizing the benefits.

  • The boundaries are eliminated, the employees are still productive, and their work satisfaction increased.
  • You can apply your learnings with employees to work with contractors or the third parties remotely as well.
  • The supervisors still have the same level of visibility, if not more, with the help of detailed reports.
  • Even if the nature of the business demands onsite work, you now have a backup option in case of emergencies.

 

The cloud-native architecture of the Smartface Platform for mobile development and CI/CD enables you to move your enterprise to the cloud with minimal dependency on onsite infrastructure for the shift to a remote working culture.

Smartface Cloud Platform is a fully cloud-based, cloud native, continuously integrated platform with multi-channel app development & lifecycle management and middleware & API management.

With Smartface, it is possible to develop native iOS/Android mobile and single-page web applications and mobile backends just with JavaScript/TypeScript knowledge and centrally manage all enterprise mobility and frontend management processes. The platform can run on compatible Kubernetes or OpenShift environments for the maximum flexibility.

You can get in touch with us for more information about the Smartface Platform.

What is NoOps and How to Achieve NoOps in Mobile App Development?

/in , , /by

As enterprises are embracing DevOps and realizing its benefits, especially in their well-established software stacks, they are challenged with another question with the increasing prominence of DevOps in the cloud applications supported with automation.

The question can be expressed as “why don’t we fully streamline the DevOps processes even further since it is more or less consist of tasks in a highly structured flow?”

The primary hurdle is the presence of physical hardware that requires maintenance in any case, but moving to the cloud and taking advantage of SaaS (Software as a Service) or PaaS (Platform as a Service) products eliminates this layer of complexity and automated DevOps starts to make more sense.

And this concept actually has a recently coined name of “NoOps”, which is gaining foothold in parallel with the cloud adoption.

 

What is NoOps?

In the simplest way, NoOps can be considered as integrating and automating (wherever possible) DevOps processes. In this sense, it is perceived as an alternative to DevOps or sometimes even as “DevOps” killer, but, it is more like an extension and further streamlining of the DevOps concept.

The term is first identified by Forrester and they emphasize that

“NoOps means that application developers will never have to speak with an operations professional again.”

Indeed, when NoOps is implemented and used in the right way and in the right conditions, it is as beneficial and productive as the name suggests.

However, it requires the right tools and preferably a full cloud presence and it should not be considered as a silver bullet for DevOps needs.

cloud-image

With the advantage of the cloud, NoOps eliminates the hassle of integration and upload/download operations.

 

DevOps vs. NoOps

There are certain fields where you have an established DevOps culture and an “Ops” team, such as maintaining critical backend applications, which may include dealing with locally installed hardware and software.

However, in emerging technologies such as mobility, it is not as easy as to find and maintain internal resources for DevOps or you might not have the operations experience that you have already gained in backend applications for decades.

DevopsvsNoops

 

 

DevOps in Enterprise Mobility

Due to its nature, mobility has its own DevOps challenges:

  • Requiring a binary to be installed on mobile devices
  • Device and operating system fragmentation making coding, testing and distribution processes demanding
  • Binary distribution regulations to mobile devices
  • Strict app signing requirements
  • Issues with keeping signing identities safe, secure and accessible
  • Complex app signing and submission processes that force the use of specific hardware and software.
  • Lengthy and complex store submission and review processes causing issues in maintenance of the apps after production

For this reason, we highlight the fact that mobile app development is only the tip of the iceberg and the lifecycle management of mobile apps (the “Ops” part) is as important as the development itself, if not more.

Mobile App DevOps Lifecycle

The Typical Mobile App Lifecycle

 

Switching From DevOps to NoOps in Mobile App Development

Achieving NoOps in mobile app development is more difficult but also more important than many other fields due to the problems outlined in the previous section.

For a true NoOps approach in mobility, it is important to be able to prevent the DevOps chain breaking from development to production, which can be achieved with a fully integrated mobility platform in the cloud.

We developed Smartface Cloud for enterprises to embrace the NoOps approach in enterprise mobility.

You can consider Smartface like an automated production line, where everything is transferred automatically between stations.

Smartface Cloud is a next generation NoOps platform with an end-to-end integrated cloud structure with development, testing, deployment, distribution and management.

What is the Difference Between a Platform and a Framework?

/in , /by

In today’s everchanging world of technology, we have a very fluid terminology, where certain words and phrases tend to overlap, and the same word may have multiple meanings in different contexts.

We usually emphasize that one of the main differences of Smartface Cloud from similar products is that

Smartface Cloud is a full-featured “mobile app development and lifecycle management platform”, not just another “mobile app development framework”.

This is usually followed by this question; what is the advantage of being a platform instead of a framework? Basically, a platform is a much more comprehensive, usually a multipurpose product and may actually host a framework in itself along with other tools. When you use a framework, you may need to form your own “platform-like” environment by combining various tools for various needs; whereas in a platform, these needs can be met from a single point and in a tightly integrated manner, increasing productivity and making it more suitable for enterprises.

Let’s check the formal definitions for clarification:

 

What is a Platform?

In traditional dictionaries, the definition of the platform is simplified down to “operating systems and/or hardware” and this is correct up to a point. We consider iOS and Android as “platforms” for which we develop mobile apps and from the same perspective, Smartface is a “cross-platform” native mobile application development platform, but this definition itself raises another question about being a “cross-platform platform”.

This is due to the fact that the changes in technology is much faster than the changes in the language. When we delve deeper, we see that Wikipedia classifies the platform concept under the “Computing Platform” article. In this article, we see the description “Software frameworks that provide ready-made functionality” as one of the items that a platform may include.

This sheds some light on our discussion in the previous section but raises yet another question.

 

What is a Framework?

Again referencing Wikipedia, we see that a framework is defined as “an abstraction in which software providing generic functionality can be selectively changed by additional user-written code, thus providing application-specific software. A software framework provides a standard way to build and deploy applications.”

Therefore, we can incur that a framework is more like a tool on which you can develop software in a more organized manner and a framework can also be a part of a platform. For instance, Smartface Cloud Platform uses Smartface Native Framework to produce native iOS and Android apps.

 

Then, what is the advantage of using a Development Platform instead of a Development Framework?

With a framework, you only get the underlying technology for development (e.g. a language standard such as JavaScript along with an SDK), usually a packager/compiler (e.g. a command-line tool) and sometimes a development environment. Although some frameworks may offer helper tools, that’s usually all. A framework is more like a facilitator than a complete solution. For instance, to use a mobile application development framework to build and deploy mobile apps:

  • You may need to download the framework itself along with Android Studio and Xcode so that it supports the targeted operating platforms.
  • If there is an update, you may need to update all the components and dependencies separately.
  • To build an app, you need to first package it in the framework and then compile it separately in the respective platform tool for iOS and Android.
  • For the rest of the mobile application lifecycle such as testing and distribution, you need to resort to third party tools, all of which may require separate configuration efforts.
  • If there are no integration between these tools, you may need to do uploads and downloads all the time or build your own.
  • If the tools don’t have cross-platform support, you may need to do everything separately for iOS and Android twice.

 

On the other hand, if you use a mobile application development platform which also includes a mobile application framework, everything will be much easier, productive, faster and less error prone.

In that sense, a mobile application development platform is a complete solution for software development with an integrated suite of tools and frameworks.

 

Smartface Cloud Platform

 

For instance, Smartface Cloud is a fully integrated end-to-end mobile application development and lifecycle management platform and offers much more than a framework with:

 

The only Cloud IDE for cross-platform native development:

  • Design and develop native iOS and Android apps just with JavaScript knowledge with a full WYSIWYG editor and a cloud IDE right in your browser. No downloads or configuration needed.
  • Automatically updated environment, no need to maintain third-party tools like Xcode or Android Studio.
  • No dependency on a single PC, can be accessible from anywhere from any device.

 

Testing Distribution:

  • Publish your apps from development to testing, no binary operations needed.
  • Distribute apps internally to testers and teams and keep track of downloads.
  • Full version history archive with all binaries.
  • Re-sign applications for production without going back and forth to the development module.

 

Cloud Signing Identity Management:

  • No need for a Mac or any other tools to generate iOS and Android signing identities.
  • Keep the iOS certificates and Android keystores secure and in a centralized location.
  • No need for keeping local copies and sharing certificate files.

 

Cloud iOS and Android App Build:

  • Direct APK and IPA output from centralized signing identities. No need for a Mac and no dependency on specific environments.
  • Apps can be built with any type of certificate.
  • Full individual build history for tracking and auditing.

 

Submission to Public Stores:

  • Publish your apps from development or from testing to public store submission, no binary operations needed.
  • Ability to upload apps directly to the App Store and Google Play.
  • No Mac needed and no need for any download/upload processes.

 

Single Link Distribution for Marketing and Deep Linking:

  • Single, shortened link and QR Code for multiplatform public store URLs with URL scheme and intent support and application install detection for deep linking.

 

Enrollment-free Enterprise App Store:

  • Publish your apps from development or from testing to the enterprise app store, no binary operations needed.
  • In-house, enterprise-specific, customizable app store to provide access to in-house apps (B2E, B2B) with internal authentication (LDAP, OAuth) and custom domain support. Supports all types of apps.
  • BYOD-friendly. No need for enrollment to MDM.
  • General and individual reports about users and apps.

 

Remote App Update:

  • Live update for native apps with hot deployment.
  • No need for App Store review and complete app updates.
  • Always deliver the latest and the best experience.

 

Team Management with Notification Center:

  • Module-based team and role management. Segregation of duties for separating roles like development, DevOps and distribution, etc. for compliance and control
  • Email notifications for full control over each step of the mobile application lifecycle for increased collaboration and agility. Keep track of teams and actions.

 

If an enterprise prefers to use different frameworks for all of these features, the enterprise may also need to form a large technology stack that is required to be maintained and integrated manually. However, this is not viable and productive for most enterprises and this is the reason why a platform is much different than a framework.

A full-featured mobile application development platform like Smartface offers much more than just a development framework and minimizes the manual operations and streamlines the enterprise mobility processes.

Smartface Cloud: The Next Generation of Enterprise Mobility

/in , /by

We are happy to announce that our next generation product Smartface Cloud is live. Smartface Cloud facilitates mobile transformation with enterprise mobility in the cloud.

You can register for free at https://cloud.smartface.io and start using it right away. No download or setup is necessary and it is free for a lifetime.

You can quickly start mobile app development in your browser with the Cloud IDE and this is just the beginning. Once you develop your app, you can manage its lifecycle end-to-end with enterprise mobility modules in Smartface Cloud.

 

With the Cloud IDE, you can develop native iOS and Android apps just with JavaScript knowledge. It works on any modern browser and on any OS. You can use the Smartface “on-device emulator” at https://smf.to/app (you need to access the link from your phone) to view your app on real iOS and Android devices instantly and wirelessly with wireless debugging on Android. Smartface Cloud Development module comes with day-one support for iOS 10 and Android 7.

For more information about Smartface Cloud, you can access the following resources:

Start using Smartface Cloud at https://cloud.smartface.io

Happy mobility,

Smartface Team.

Extending Smartface with Native iOS and Android Plugins

/in , /by

Smartface plugin interface is now open to all users, including the free Community license. Everyone can create their own native Objective-C and Java plugins for Smartface App Studio. The possibilities to extend your Smartface apps are now endless.

Smartface is a JavaScript based cross-platform native framework and it already provides a JavaScript interface to native OS components in iOS and Android. However, there might cases where you need to use a specific SDK for a specific purpose or a custom component.

Some of the examples for such cases are:

  • SDKs for different enterprise systems and frameworks for security, connectivity, etc.
  • SDKs for cloud services (you can use any cloud service with Smartface)
  • SDKs for mobile services such as analytics, in-app communication, application health monitoring, etc.
  • Custom user interface components such as animations or buttons and menus with different designs and interaction options or gesture components
  • Supporting beacons on Android (iBeacon is already supported in Smartface) or using a third party beacon framework

 

Plugin is a broad term and its definition tends to change in each platform, where they might be named as addons, extensions or components in different platforms. In Smartface, we have elected to define native plugins as any kind of native code/functionality that is implemented in Smartface with the plugin interface.

With native plugin support in Smartface, you can even implement full apps developed in Objective-C or Java.

In the lifecycle of a plugin in Smartface, there are two different phases involved.

If you are a Smartface developer who just wants to use a third party plugin, the development and packaging steps are not important for you. You may skip to the “Using the plugin” section to use any plugin just in two steps.

 

1. Native plugin development and packaging

The development and packaging are specific to each native platform and require some familiarity with the native development tools.

i. Developing iOS plugins with Objective-C:
  • Create the plugin template with the CLI tool
  • Merge your native code with the template
  • Fill in the configuration file
  • Define classes to be used in JavaScript
  • From the project files, generate the plugin file using the CLI tool

You can distribute the generated zip file, the Smartface plugin, in any way you like. For technical details on iOS plugins, you can refer to the Developing iOS (Objective-C) Plugins for Smartface guide and for a step-by-step generation of an iOS plugin, you can refer to the Hello World with iOS Plugin guide.

 

ii. Developing Android plugins with Java:
  • Download the plugin template from Smartface website
  • Put the template under Java folder in your project in the Android development environment
  • Fill in the configuration file
  • Define classes to be used in JavaScript
  • Generate the plugin file using the CLI tool
  • Build the project apk
  • From the apk, generate the plugin file using the CLI tool

You can distribute the generated zip file, the Smartface plugin, in any way you like. For technical details on Android plugins, you can refer to the Developing Android (Java) Plugins for Smartface guide and for a step-by-step generation of an Android plugin, you can refer to the Hello World with Android Plugin guide.

 

 2. Using the plugin in Smartface (JavaScript development)

It is very easy to implement any native plugin in Smartface just in two steps.

  • Get the plugin file from the developer and put it inside the Data->Plugins folder in your project structure
  • Activate the plugin in Project Details->Plugins section in Smartface IDE

You may refer to the Smartface Plugin guide for technical information.

 

Also, please note that with this plugin update, there are changes in the implementations of the third party plugins already available in Smartface. Now, they are presented as third party plugins as well.

You may refer to the guides section for more information about the changed components and you can visit the Smartface Developer Center for more native iOS and Android development resources. For updates, you can follow us on Twitter @smartface_io

With plugins, you can utilize any iOS and Android native code, component and SDK in Smartface to develop native apps just with JavaScript.

Download Smartface now and start native iOS and Android development!

Smartface Architecture for Native iOS and Android Development with Single JavaScript Codebase

/in , /by

Smartface is a native cross-platform JavaScript interpreter framework for iOS and Android. The framework consists of two main elements: Run-Time Engine and Desktop IDE. The IDE is Windows-based and has no dependency on Mac for iOS testing and debugging, meaning that whole iOS development can be done on Windows. Run-time engine is explained below in more detail.

  1. Overview of the Architecture
  2. Run-time Package
  3. Interaction
  4. Security
  5. Extensibility
  6. Performance
  7. Stability
  8. JavaScript Compatibility
  9. Connectivity

 

1. Overview of the Architecture

Smartface run-time engine is built upon a single Core, which is common across platforms:

Smartface Architecture Diagram

Smartface Architecture Diagram

1.1. Smartface Core

Smartface is shaped around the Core. It is written in C++ and is used across all platforms.

This Core contains the main logic of the engine, such as event triggering, encryption & decryption, data relay & translation between other modules.

Every JavaScript object or method that interacts with native objects first interacts with the Core, which in turn updates the native object via the platform specific bridge. This abstraction model in the Core ensures single codebase development in Smartface.

1.2. Native OS Layer

In each platform, native objects such as Label, Editbox (textbox) are provided. Each OS platform provides bindings for the native objects written in the native development language of the platform: Objective-C for iOS and Java for Android. OS specific behaviors are implemented at this level.

1.3. Android and iOS Bridges

The OS Bridge establishes communication, translation and wrapping between native objects and the Smartface Core. The bridge is developed in C++ and is customized for each OS based on the needs of the native environment.

1.4. SQLite

SQLite engine is used as the built-in database within the application.

1.5. Curl

Curl is the library used for network communication in Smartface, it is used both in iOS and Android.

1.6. JavaScript Engine

JavaScriptCore a part of the open source WebKit Browser engine is used across all platforms. This ensures the compatibility of JavaScript features between each platform. This engine is customized with remote debugging features.

1.7. Core Plugins

There are a number of built-in plugins shipped with the platform. These plugins have core level integration, which enables them to be bound as native objects, such as AdMob. Additional plugins can also be added with the upcoming plugin support.

2. Run-time Package

Run-time engine is precompiled targeting the OS. Smartface iOS Runtime and Smartface Android Runtime have their own separate runtime implementations. Android also has two runtime options based on CPU architecture: ARM & Intel (x86).

Smartface Native iOS and Android Runtime Packages

Smartface Native iOS and Android Runtime Packages

 

When a project is ready, it can be published from the IDE. This generates an APK file for Android, and an Xcode project in a zip file for iOS. Smartface runtime is precompiled; packaged by IDE with project files and plugins to be delivered to device.

 

Smartface Project Package

Smartface Project Package

Static project data & info is an XML data, converted to binary format on IDE to be parsed faster on runtime. This data consists of static objects, database schema and project info. Static objects are the objects designed on the IDE: UI, Network, DataSets and DataTables. If an object is declared within JavaScript code, then it is referred to as a Dynamic object.

Plug-ins are also pre-compiled and ready to be shipped out of the box.

3. Interaction

When an app developed by Smartface is published by the IDE, and Android APK file or an iOS Xcode project is generated.

After app is deployed and ready to run, it is executed as explained in the Smartface App Execution Flow.

There is an important thing to notice, every static object is loaded to the memory during startup, and dynamic objects are loaded when code calls for it.

In the JavaScript example below, there are static objects in Page1, TextButton1 and Label1. TextButton onPressed event is mapped to function Page1_TextButton1_OnPressed. When a user clicks the button to set the text of the label as given by the code below, following steps are executed:

function Page1_TextButton1_OnPressed(e) {
     Pages.Page1.Label1.text = "hello world";
}
  1. JavaScript engine accesses to Pages object, which resides in Core
  2. JavaScript engine gets Page1 property of Pages which resides in Core
  3. JavaScript engine gets Label1 property of Page1 which resides in Core
  4. JavaScript engine sets text property value of Label1 which resides in Core. While setting this value, before returning to the JavaScript Engine, Core performs following operations:
    1. Core access the native Label object through bridge.
    2. Updates the value in UI
    3. Returns to the JavaScript engine to proceed with next line. In this case, both Core and UI has the copy of the value.

 

While getting values from objects, execution occurs in the following way for the code shown below:

function Page1_TextButton2_OnPressed(e) {
alert(Pages.Page1.Label1.text);
}
  1. JavaScript engine accesses to Label with same steps explained above
  2. JavaScript engine gets value from the Core. The Core does not retrieve this value from an UI object, it directly returns the value from the value stored in the Core.

 

4. Security

Compiled C++ and Objective-C codes and obfuscated Java code hardens Smartface engine for reverse engineering.

Binary data and JavaScript code of the project are encrypted.

The Core provides easy-to-use encryption facilities to encrypt the database for security. Smartface also comes built-in with security plugins from different security providers.

Built-in level encryption keys are generated dynamically by the IDE during publishing process, this encryption key is retrieved by the master key within Smartface. This hardens the stored data against known text attacks.

5. Extensibility

Smartface is an extensible framework and third party native libraries can be added as plugins.

This integration can be done in several levels of integration between Core and Native OS level.

Some plugins are shipped with Smartface App Studio and some of them are obtained separately from external sources. Shipped plug-ins are part of the run-time engine and IDE does not add them separately during publishing process except AdMob for iOS. The other plugins are precompiled and added to the app package by the IDE during publishing. Presence of these plugins is checked by engine during runtime and feature support is managed accordingly.

6. Performance

Smartface core is developed in C++ for iOS and Android and the architecture is designed to minimize the performance loss.

There might be a performance loss up to 3%. However, this performance difference is not noticeable unless milliseconds are critical for an app.

7. Stability

Smartface Engine takes care of memory optimization; UI rich components are implemented with their memory usage optimized.

Since the framework is a product of 4 years of intensive testing, device-specific issues are addressed and solved within the framework.

For multi-threaded implementations, Smartface Engine itself takes care of thread synchronization and internal data transfer.

8. JavaScript Compatibility

Smartface supports plain pure JavaScript; it has no parts of HTML or DOM. The engine is taken out of WebKit, and stripped out everything except the JavaScript engine.

The engine is ECMAScript 5 compatible. Same compatible engine and version is used both in iOS and Android to ensure the highest compatibility of JavaScript features in both environments.

Built-in JavaScript engine of WebKit does not include remote debugging protocol and debugging features. JavaScript engine is extended with remote debugging features, enabling JavaScript debugging from IDE both in iOS & Android with full debugging features.

9. Connectivity

Smartface has built-in web socket client support. Any application developed using Smartface can consume any web services without any problem, such as Restful, SOAP and OData services. This web socket client architecture is built on Curl. Curl is a very popular and stable cross-platform connectivity library, which eliminates the behavioral differences between iOS & Android.

Any mobile app can call the app developed with Smartface in a bidirectional way with passing data to and from it.

Apps developed with Smartface can register for receiving push notifications for iOS and Android. Using push notifications, apps can receive push data.

iOS Framework also has support for iBeacon, it can receive data from iBeacon source and estimate proximity.

 

With its superior architecture, Smartface enables you to develop native iOS and Android apps with a single JavaScript codebase. Download Smartface now and start developing mobile apps right now!

15 Frequently Asked Questions about Smartface

/in , /by

Here we present you the 15 most frequently asked questions about Smartface from our community and from our enterprise customers. You can find answers to business-related and technical questions.

 

  1. What kind of mobile applications can you develop with Smartface?
  2. Why should I choose Smartface?
  3. How do you handle operating system and device differences and fragmentation?
  4. How do you support new operating system versions?
  5. How does Smartface work? Could you provide more information on the architecture of Smartface? Is Smartface open source?
  6. Since Smartface is an interpreter framework, would it be possible to update the source code of the application on the fly by downloading it from an external source during runtime?
  7. Are there any performance differences between apps developed with Smartface and apps developed with Objective-C/Swift/Java?
  8. Are there any app size differences between apps developed with Smartface and apps developed with Objective-C/Swift/Java?
  9. What if a device/OS feature is not available in Smartface?
  10. Can I use different JavaScript libraries in Smartface?
  11. Can Smartface do everything a hybrid platform is capable of?
  12. There are many open-source resources for platform-based development. Is it possible to use these in Smartface?
  13. How secure is an application developed with Smartface?
  14. How do you provide the native experience with single codebase in Smartface?
  15. How is memory management handled in Smartface?

 

  1. What kind of mobile applications can you develop with Smartface?

Smartface is a flexible platform and you can develop almost any kind of general-purpose apps for any form factor for iOS and Android, including highly complex apps such as mobile banking or m-commerce.

Smartface has 100% native API access so that you can utilize all native features shipped with the operating systems with the Smartface framework.

There are two types of apps that Smartface is not suitable for: games requiring advanced processing and specific-purpose utility apps requiring system-level access such as memory optimizers or battery life managers.

 

  1. Why should I choose Smartface?

The main focus of Smartface is productivity. Cross-platform native development with Smartface is around 4 times more productive than platform-based native (Obj-C, Java) development. You can see even more reasons why to choose Smartface in our Why Smartface page.

 

  1. How do you handle operating system and device differences and fragmentation?

Smartface release cycle consists of 4 major version updates in a year as well as periodic minor updates. Besides introduction of new features in each release, necessary backward and forward compatibility changes are provided. (e.g. support for new CPU architectures such as iOS 64-bit or OS-level changes such as keyboard handling)

To minimize the impact of OS updates on developers, the change processes is handled by Smartface as much as possible. In case of changes that will affect the projects, the developers are informed with the release notes. (e.g. deprecated features)

Smartface closely tracks upcoming iOS and Android operating system updates and plans the major releases based on the release timings of GM or public release of new operating system versions.

For developers, it is sufficient to update their projects to the latest version of Smartface for their apps to support the latest operating system versions, reducing the operational costs required for operating system version migration.

 

  1. How do you support new operating system versions?

As soon as a new iOS or Android release is open for testing, Smartface updates the framework in accordance with these new releases. As one of the benefits of the Smartface enterprise license, Smartface beta releases are instantly accessible by Smartface enterprise customers.

When the new iOS or Android version is released publicly, new version of Smartface is released to the community in parallel.

 

  1. How does Smartface work? Could you provide more information on the architecture of Smartface? Is Smartface open source?

Smartface is an interpreter framework. The objects developed in design time are optimized and converted into native components during runtime. You can refer to the Smartface architecture document for more information.

Enterprises can request access to Smartface source code with specific agreements. With special training and agreements, enterprises can also develop native C++ plugins in our core.

 

  1. Since Smartface is an interpreter framework, would it be possible to update the source code of the application on the fly by downloading it from an external source during runtime?

As an interpreter framework, Smartface processes the code during runtime; therefore, it is not necessary to include all JavaScript codes in the project. Even the full native app can be downloaded from a server, which is something that cannot be done with the platform-based native frameworks (Obj-C, Java).

Technically, there is no limitation on this way of working and for B2B apps that are distributed with enterprise distribution, it is preferred. However due to App Store restrictions, the critical path of a B2C app must be coded inside the app and code updates are recommended to be done only up to a certain extent.

 

  1. Are there any performance differences between apps developed with Smartface and apps developed with Objective-C/Swift/Java?

Smartface core is developed in C++ for iOS and Android and the architecture is designed to minimize the performance loss. There might be an insignificant performance difference. However, this performance difference is not noticeable unless milliseconds are critical for an app such as a live stock exchange application.

 

  1. Are there any app size differences between apps developed with Smartface and apps developed with Objective-C/Swift/Java?

The framework Smartface uses during runtime has a fixed overhead. Therefore, even if in a “Hello World” application, the app size cannot be smaller than the framework size. As the number of screens in an app does increase, with 20 screens or more, this difference is negligible; or with 40 screen or more, it uses less size compared to native apps, depending on the implementation.

 

  1. What if a device/OS feature is not available in Smartface?

Smartface supports most of the functionalities available in iOS and Android operating systems. If there is a specific functionality you would specifically like to check before starting your project, you can search it in the API docs or ask Smartface community on Stack Overflow.

If a feature is not yet available, you can check our roadmap for more information if it will be implemented. Regardless of the roadmap, enterprise customers can request additional features, which they can get as plugins or patches.

For the community developers, the recommended solution is to implement additional features as plugins. Any objective-C or Java code can be added as a plugin to Smartface and can be mapped to JavaScript commands to be used in your projects.

 

  1. Can I use different JavaScript libraries in Smartface?

Smartface supports JavaScript fully, however it is a native framework and it does not have DOM support. Therefore, any JavaScript library that does not contain a DOM implementation can be used within Smartface directly.

 

  1. Smartface is native but can it do everything a hybrid platform is capable of?

Although we recommend you to take advantage of quick and easy native development with Smartface; Smartface offers the flexibility of developing apps in a hybrid structure with the WebView component. You can refer to the WebView guide for more information and the differences between native Smartface and hybrid platforms.

 

  1. There are many open-source resources for platform-based development. Is it possible to use these in Smartface?

With the plugin support, any objective-C or Java code can be used in Smartface, but we recommend checking the Smartface API docs first. Among the hundreds of apps developed with Smartface, it is highly likely that a similar implementation has already been done.

You can also ask the Smartface community on Stack Overflow for detailed use cases. Moreover, Smartface plugin market will open soon, allowing developers to share their work.

 

  1. How secure is an application developed with Smartface?

We take security concerns seriously and implemented measures to protect the code as well as the application data with built-in security features. As a result, financial institutions feel comfortable in using our solution for developing apps like mobile banking and mobile authentication.

Core of the app is written in C++ and it cannot be decompiled and for JavaScript, code obfuscation is used to protect from decompiling. For advanced security features, Smartface supports Kobil and Vasco solutions out of the box. You may refer to our security guide for securing your app in Smartface.

 

  1. How do you provide the native experience with single codebase in Smartface?

The architecture of Smartface ensures the native experience as the objects developed in design time are optimized and converted into native components during runtime with the JavaScript wrappings for native UI and components for each platform. The engine itself uses shared native C++ code for iOS and Android with bridge architecture.

For differentiating features, we check each feature in iOS and Android and when a feature is only available in one platform, it is overridden if it doesn’t fit that platform or it is duplicated with a custom implementation, if it has the potential to affect the experience.

 

  1. How is memory management handled in Smartface?

Memory management and concurrency management is handled at the platform level, so you don’t need to worry about it during development. You can refer to the Memory Management in Smartface and Memory Management with Dynamic Objects articles detailing the memory management in Smartface:

 

If you have another question that is not answered here, you can contact us.

Smartface vs. Xamarin (Cross-Platform Native Frameworks)

/in , /by

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)

 Yes
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.

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

/in , /by

 

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

10 Most Common App Security Mistakes

/in , /by

Why Mobile App Security?

App security mistakes for Android and iPhone are generally a lesser prioritized area for a mobile developer, mostly because due to the time pressure. It does not usually get what it deserves in project plans. Moreover, in case of absence of a security owner in project teams, no one claims responsibility. That’s why mobile app security is a matter of attention left only to the developer’s initiative.

Security and Usability are two concepts that are inversely related. Highly secure solutions require additional processes and flows. However, most business units, working directly with consumers, don’t consider app security as the first priority.

In practice, nobody brings out a security concern unless something really goes wrong in case of “hacking”. Most application developers are not taking care of specific Android security and iPhone security tests. (Application Security Test).

Always keep in mind the principle that No app is %100 safe!

icloud-security-risk-1024x426

What Should You Do for App Security?

Our purpose is to make your app more secure than others by using quick and simple features, hence discouraging the hackers to mess with your mobile application. Make your app ready for mobile security. Here are the 10 Most Common App Security Mistakes:

1. Data Store Approach: First of all, sensitive data should not be stored on the device during runtime as much as possible. Data can be processed in case of need and should be deleted immediately when not needed. In case of a data storage need on the mobile device, data should be encrypted and stored in the documents folder. Passwords should be stored in KeyChain for iOS and KeyStore for Android security. This is also important for app store security checks.

2. Missing front-end validation: Missing data entry validation causes both security and formatting issues. These may be things like letting alphanumeric values in numeric fields, missing masking on formatted fields, not checking for high risk character values such as <>` ” ()|#. Such missing validations may cause security breaches by allowing remote code execution or unexpected responses.

3. Server Based Controls: Application development is a client side operation. Server side is the place where you should store and manage the data. Server side checks should be applied regardless of channel (mobile, web, etc…) for data security and formatting. We do not mean iCloud keychain or a similar feature, please take care. This is about the app-specific backend security. There are also security concerns for Apple iCloud, however this is Apple’s work to do it more secure!

4. SSL: HTTPS must be used for secure transmission of sensitive information. If possible, a custom certificate should be used instead of the certificates from the built-in device certificate store. The certificate that is unique to the app and the server should be embedded inside the app.

5. Obfuscation: It is very important especially for Android apps to go through obfuscation. If script files are also used in parts of the app, these files should be taken through obfuscation as well.

6. Comment Lines: Explanatory data, included as comment lines may be viewed by others if the application is decompiled. This is very simple but a common mistake both for Android and iOS apps. This does not mean that you shouldn’t use comments during app development, just don’t forget to remove them from the production version of your app.

7. Excessive Permissions: When editing permission preferences for Android apps, only the permissions that are absolutely needed should be enabled. Permissions with access to personal information, such as “access to contacts”, should be avoided as much as possible for Android security. If anything goes wrong, there is less chance of a data breach.

8. Encryption: The key used in encryption should also be encrypted and stored in secure storage. The installation file should also be obfuscated. Another dangerous practice that should avoided is the downloading of the encryption key from server during runtime.

9. Rooted/Jailbroken Devices: It is not possible to store totally secure data in rooted devices as root permissions provide unlimited access to the device filesystem and memory. However, it is possible for developers to check if the device is rooted or not. This risk should be noted and evaluated based on project scope for all flows and processes.

10. Application Tampering Protection: The application binary files (.apk or .ipa) can be altered and published in different markets by hackers. They may inject malicious code in your app or they may crack mobile apps to bypass license and payment restrictions. Nowadays it’s even possible to crack in-app purchases and license checks just by emulating app store responses. Therefore, application integrity and in-app purchases should be checked with a third-party trusted server to prevent such cases. For this purpose, there are some good solutions available in the market. Again, this is very critical for Google Play and iTunes App Store security.

app_security

If you are developing your app with a Platform-Based Approach (Obj-C, Swift, Java) the items above should be managed entirely by yourself or your team. However, if you’re using a cross-platform native framework approach, most of the items above are covered by the mobile development framework for mobile app security.

We especially suggest you to use cross-platform native frameworks for mobile security industry. You may have already faced the well-known risks of cross-platform hybrid frameworks, such as DOM Payload, Scripting Engine Scope, etc. You can assess security capabilities of the Smartface Native Framework with the information from the link below:

 

–    Security in smartface.io

 

 

If you want to develop native iOS and Android apps with one of the most secure native app development environments, just click the link below to get it free:

Download Smartface App Studio and iOS emulator on Windows PC!

 

Happy and secure coding 🙂

@osmancelik
CTO, Smartface Inc.