A software developer, web developer, and mobile app developer enter a bar, and immediately turn around and run for their lives.

Why?

Short answer — memory leak

The long answer? Start scrolling to find out 😆

Before moving on, you might be wondering what is memory leak. It is a scenario that occurs when developers or software unintentionally do not free an allocated block of memory when it’s no longer required. In such situations, the performance of the software or application starts decreasing until it fails or becomes extremely slow.

So, how can this situation be resolved or prevented in the context of app development in Apple? Let’s take a look.

An apple a day keeps memory leaks away?

So, how does app development take place in the context of Apple’s app development ecosystem, i.e., iOS, macOS, watchOS, and tvOS?

Across Apple’s ecosystem, app development memory is managed with ARC’s (Automatic Reference Counting) help. ARC helps operating systems track, allocate, and deallocate memory for objects participating in a particular program. However, the OS does require developer’s assistance when it comes to managing the memory footprint.

The OS knows when to allocate and deallocate memory, but it doesn’t understand the reasoning behind managing the memory. Hence, it falls to the developer to design the interactions of objects in an application to ensure the ARC understands why memory has to be allocated and deallocated.

ARC manages the memory for an object by injecting retain and release method calls before and after its usage. The ARC keeps an object in memory as long as the object has a reference count of 1 or more. When the reference count falls to 0, the ARC will remove the object from memory. But what happens if the object is not removed from memory? Let’s examine it with an example.

As you can see in the graph above, several objects hold references to each other. Once ‘App Delegate’ gets deallocated, it removes the reference to ‘View Model’ while deallocating it as well. This similar process also continues with the ‘View Model’ and ‘Department Model’.

However, as you can see, ‘Department Model’ and ‘Employee Model’ still reference each other, even when no other object is referencing ‘Department Model’. Since they are still referencing each other, they exist in memory, thus causing the infamous memory leak (and giving you the long answer 😉)

How to catch memory leaks?

Apart from employing ARCs, there are other methods for catching or preventing memory leaks; tools and tests are two such ideas that come to mind.

Xcode has several tools that help developers debug and catch memory leaks; however, these primarily come into play after the features and functionalities are developed and can be time-consuming.

On the other hand, there are tests that can actually catch memory leaks, one of them being the XCTest. So, let’s examine how implementing an XCTest can help detect memory leaks, and here we dive into the practical world of coding.

Step 1

The first step in this process is creating an Xcode project and a test target. For this example, we’ll be creating four classes — Employee, Department, DepartmentViewModel, and Capture_Memory_Leak_with_XCTestTests, which is an XCTestCase subclass.

Step 2

Implementing the application’s main target is the next priority

import Foundation
 
class DepartmentViewModel {
    
    var department: Department
    
    init(_ department: Department) {
        self.department = department
    }
    
    func add(_ employee: Employee) {
        department.employees.append(employee)
    }
}
 
class Employee {
    var id: Int
    var name: String
    var department: Department
    
    init(_ id: Int, name: String, department: Department) {
        self.id = id
        self.name = name
        self.department = department
    }
}
 
class Department {
    var id: Int
    var name: String
    var employees = [Employee]()
    
    init(_  id: Int, name: String) {
        self.id = id
        self.name = name
    }
}

Step 3

The next step is to implement the application’s test target.

import XCTest
@testable import Capture_Memory_Leak_with_XCTest
 
class Capture_Memory_Leak_with_XCTestTests: XCTestCase {
    
    /// holds references of instance of each type
    /// On deallocation of `viewModel.department` these types will be nil'ed out.
    private weak var weakDepartment: Department?
    private weak var weakEmployee: Employee?
    
    override func tearDown() {
        super.tearDown()
        assertMemoryLeakOnEmployee()
        assertMemoryLeakOnDepartment()
    }
    
    private func assertMemoryLeakOnEmployee() {
        /// Once `employee` instance is deallocated then `weakEmployee` will also gets deallocated &  below test will success
        XCTAssertNil(weakEmployee, "Employee Object is leaking")
    }
    private func assertMemoryLeakOnDepartment() {
        /// Once `department` instance is deallocated then `weakDepartment` will also gets deallocated & below test will success
        XCTAssertNil(weakDepartment, "Department Object is leaking")
    }
    
    func test_employeeExistsInDepartment() {
        let iOSDepartment = Department(1, name: "iOS")
        let abc = Employee(1, name: "ABC", department: iOSDepartment)
        
        let viewModel = DepartmentViewModel(iOSDepartment)
        viewModel.add(abc)
        
          /// Entire memory leak magic happens here.
        /// By end of this function, If proper object deallocation happens, it is expected that below instance(s) will be nil'lyfied
        weakEmployee = abc
        weakDepartment = iOSDepartment
        
        let employeeExist = iOSDepartment.employees.contains {
            abc.id == $0.id
        }
        
        XCTAssertTrue(employeeExist)
    }
}

As you can see in the source code in steps 2 and 3, the weakEmployee and the weakDepartment instances in the application’s test target must be weak to ensure the test is carried out seamlessly.

So how do you find out or catch the memory leak? First, the presence of XCTAssertNil in the application’s main target informs us about the existence of the memory leak.

However, the leak occurs in the weakEmployee and weakDepartment instances from func test_employeeExistsInDepartment(). This function holds the local instance property in the test class scope, so during tearDown() method call asserting the deallocation of instances must be eliminated.

You can also handle the memory leak by prefixing weak or unowned to property var department: Department from the Employee class.

This is how you can prevent and catch memory leaks with XCTest, which would also help in attracting the software, web, and mobile developers who ran for their lives 😆

XCTest: The bane of memory leaks? was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hey Androiders 👋, this is a blog where we’ll discuss how we can use JetpackCompose @Preview in a different way to make our app development more productive!

Before starting of JetpackCompose @Preview let's discuss how we can enable Android projects with required dependencies. We need to add tooling dependencies which will support @Preview annotation in the app:

Simple Composable Preview

Create a new Composable using @Composable annotation:

and create a preview for the above Composable annotated with @Composable and @Preview to show a preview in the Android studio window:

Composable preview in the design window:

UseCases:

Now let’s discuss this differently Preview parameters and use cases where we can update our Preview annotation and make the preview more useful.

Case 1: Light/Dark theme preview:

Output:

Case 2: Preview your entire screen with system UI controls along with different device specifications like in tablets, phones etc:

specs:

Case 3: See preview with enabling background colour for that Composable:

Case 4: To test different user locales, you need to add the locale parameter:

MultiPreview Annotations rescue 🔥:

Using MultiPreview, we can define multiple @Preview annotations and create a defined annotation that we can reuse instead of writing multiple Preview annotations every time. For example, you can use this annotation to preview multiple devices, font sizes, or themes simultaneously without repeating those definitions for every single composable.

See the example code below for how I created MultiPreview class to define reusable DevicePreviews annotation that we can reuse every time where we want multiple device preview

Using @DevicePreviews class:

Output:

Spoiler alert 🤯 !

You can combine multiple multipreview annotations and normal preview annotations, to create a complete set of previews. Combining multipreview annotations doesn’t mean all the different combinations are shown. Instead, each multipreview annotation acts independently and renders only its variants.

Preview action menus🔥:

1. Animation Preview: Using this menu you can inspect animations defined using Jetpack Compose animation framework frame-by-frame. Currently, limited APIs are supported to view animation previews like updateTransition , AnimatedVisibility , CrossFade etc.
2. Interactive Mode: Using this menu we can make a live preview of gestures like click events and check composable in a different state like the check button in enabled/disable mode:

3. Run Preview: Using this menu, we run individually composable in isolation mode on the testing device to see how that particular composable looks on a real device/emulator.

Let’s take a look at the summary of what we have learned:

• How we can enable the Jetpack Compose app for Preview
• How we can use Preview Annotation for composable
• How we can use multi preview to combine multiple Preview and reuse it
• How to use Preview action menus

Wrap Up!

So, that was pretty cool, right? This is all the stuff related to JetpackCompose Preview.

More you can learn at Android Studio support for Compose:

Android Studio support for Compose | Jetpack Compose | Android Developers

Thanks for reading this article. Don’t forget to clap👏/recommend as much as you can and also share📤 with your friends. It means a lot to me.

For more about programming, follow me and MutualMobile Engineering, so you’ll get notified whenever a new article is posted.

You can find our MutualMobile Engineering best articles here.

Also, Let’s become friends on Twitter, GitHub

Jetpack Compose Preview like a pro! was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.

What would developers do if Swift never existed? Act like disgruntled pelicans?

Jokes aside, Swift has become the vital tool of choice for developers for the benefits it brings to the table. And what works even more in Swift’s favor is the regular addition of exciting tools and features. Swift Charts is one such feature that was introduced at WWDC 2022.

Data visualization has always helped simplify complex data sets while enhancing presentation. And now, with the help of Swift Charts, developers can implement the same in their apps.

Introduction to Swift Charts

So, what is Swift Charts? It is a powerful, flexible framework that can create aesthetically pleasing charts using little code. Like SwiftUI, it uses a declarative syntax. Hence, developers familiar with SwiftUI can seamlessly use Swift Charts.

Earlier, developers had to contend with external libraries for creating charts in their apps, but not anymore.

Swift Charts also provides out-of-the-box support for dark mode, device screen sizes, dynamic types, voiceover, audio graphs, localization, and multi-platform support. This exciting framework is available for Xcode 14, while also providing support for iOS 16+, macOS 13+, Mac Catalyst 16+, tvOS 16+, and watchOS 9+.

Exploring Swift Charts

Swift Charts is fun and exciting to use, and it comes with six default chart types called Marks. The six chart types are bar, line, point, area, rule, and rectangle. Additionally, these charts are extensible; hence they can be customized.

Now, let’s explore these charts with the help of an example.

Sip n Snacks is an Indian fast food restaurant that serves three types of dishes — dosa, paratha, and chaat. This restaurant is open to customers during morning and evening hours. So, let’s analyze their sales data during the weekdays with the help of charts. This analysis can help the restaurant to plan its staffing and procurement for the week as per the sales trends.

Let’s start by creating all the enum types that would be required:

• FoodItemType enum with cases for dosa, paratha, and chaat as food items for sale.
• WeekDaysType enum with a case for each day of the week is created.
• TimingType enum with cases for morning and evening hours.
• ChartType enum with cases for different chart types in Swift Charts.

So, the image below shows the model code we will be implementing.

https://gist.github.com/SahilMutualMobile/3b4cb73c87071b0e06a4bc80c3ce0185

Code block 1: Model code‍

Next, we’ll create two data sets for morning and evening hours. For this, we’ll create two constants — morningSales and eveningSales, which are arrays of RestaurantSales.

Sample data code for morningSales

https://gist.github.com/SahilMutualMobile/3df034bb8029d9e2f0e6b1d5263eb023

Code block 2: morningSales sample data‍

Sample data code for eveningSales

https://gist.github.com/SahilMutualMobile/fe1912b57d228ecac52d2821380e1681

Code block 3: eveningSales sample data‍

So, now let’s explore the various types of charts.

Bar charts

The process to create a new chart in Swift starts off by defining a chart block. Additionally, you can also pass a data array within the rounded brackets. In this example, it is an array of RestaurantSales. Since we have to loop through the days of the week, we have to define a ForEach block for the itemSales.

Now, we can create a bar chart with a BarMark block, which will accept x and y coordinates for the graph. In this case, x axis is the days of the week while y axis is the sales numbers.

Since we need to show sales for the various food items, we’re adding a foregroundStyle modifier to the BarMark block with foodItemName. This will show different colors for each food item and Swift will automatically provide the colors for differentiation.

https://gist.github.com/SahilMutualMobile/5dd167f747b8ada1b128af7c9ef25c0e

Code block 4: Bar chart code‍

Line, point, and rule charts

Line charts in Swift are similar to bar charts with the only difference being the code block, which is shown as LineMark.

There is also an option to superimpose a point chart on a line chart by using a shorthand modifier to the LineMark code block. In this example, we are also superimposing another chart known as the RuleMark, with which we can represent a straight line in the x or y axes. Here, its being used to indicate a breakeven point in sales on the y axis.

https://gist.github.com/SahilMutualMobile/224893cdb9abe2280e39e83cd9b13296

Code block 5: Line chart code with symbol modifier and rule chart overlay‍

‍Area chart

Like the LineMark, we can also create an area chart with an AreaMark block.

https://gist.github.com/SahilMutualMobile/b70735017baac6601c84d6ad8a0d07a6

Code block 6: Area chart code‍

Rectangle chart

Like the LineMark, we can also create an area chart with an RectangleMark block.

https://gist.github.com/SahilMutualMobile/aca67f631be20a98be0021c042b25090

Code block 7: Rectangle chart code‍

‍The beauty of Swift Charts

Now, lets take a look at all the charts on a single screen. This can make the visual differences between the various charts easy to understand. Swift Charts provides us with automatic animations during chart transitions, but we have implemented a custom easeIn animation in this case.

https://gist.github.com/SahilMutualMobile/d4e1d4e24444db09133cee2f972853bf

Code block 8: All charts in one screen code‍

‍As you can see Swift Charts is fun to use and also adds an interesting feature in iOS apps, which helps enhance user experience.

And that ends the three-part series of our adventures with Swift. So, if you’re looking for an app to be built for iOS, we’d love to hear from you and bounce ideas off together.

Swift III: A beginner’s guide to Swift Charts was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.

Swift II — WWDC 2022 heralding a new dawn for Generics?

Apple doing something new at the WWDC. Well, that shouldn’t come as a surprise at all.

That being said, Generics got its share of extra attention and shot into the limelight due to WWDC 2022.

Now, coming back to the highlights of WWDC 2022, Apple announced exciting new additions to Generics as part of Swift 5.7, leading to it getting its day in the sun.

Generics in Swift 5.7

So, what are these new additions to Generics in Swift 5.7 that got developers excited?

• The usage of some keywords in parameter position.
• The usage of any keyword with a protocol having associated types.
• The unboxing of underlying concrete types to access type-specific relationships.

It’s also important to note that these were released with Xcode version 14. So, let’s explore these new additions with our pizza shop example; you remember that, don’t you?

Protocol with associated type

An associated type gives a placeholder name to a type that is used as part of the protocol. Using our pizza shop example, we start by creating PizzaTopping enum that will have various pizza toppings.

https://gist.github.com/SahilMutualMobile/a8ddaca0641834585d90fd296cbaca2c

Next, we create a protocol RestaurantItem that will have an associatedtype Message, which has a default type of String. Also, we have defined two methods — acceptOrderItem and prepareOrderItem, and both return Message type.

We will use this RestaurantItem protocol to create concrete products. For our example, we will also create PizzaType, SideDishType, and DrinkType types that conform to RestaurantItem.

https://gist.github.com/SahilMutualMobile/dca02c7ad9c31266508cdc56c0a3001d

Pizza product

Here, we’ll create a concrete product for three types of pizza — Margherita, farmhouse, and golden corn. We start by creating an enum PizzaType that conforms to String and RestaurantItem protocol while defining three cases for the three types of pizzas. Additionally, a variable type called toppings is introduced, which will hold an array of PizzaTopping depending on the case of the enum instance.

We also need to implement the two methods from RestaurantItem protocol, acceptOrderItem, and prepareOrderItem. This is because these functions will form an appropriate string based on the pizza selection and return the String.

https://gist.github.com/SahilMutualMobile/137f879f55e78bf18ed57d12c8e46409

Side dish product

Similarly, we also create a SideDishType that conforms to String and RestaurantItem protocol.

Furthermore, we also define two cases for fries and calzone while implementing the acceptOrderItem and prepareOrderItem methods.

https://gist.github.com/SahilMutualMobile/f24ed9e30dc8cc66c80efccc6ff38a44

Drinks product

Continuing in the same vein, we create DrinkType that conforms to String and RestaurantItem protocol.

We also define two cases for soda and lemonade while implementing the acceptOrderItem and prepareOrderItem methods.

https://gist.github.com/SahilMutualMobile/b3e1c5e35d073094e55052c867bf44cf

Implementation of the pizza shop

Here, we have created a new class called PizzaShop. To proceed, we also declare a variable orderNumber to keep track of the order number.

To attract customers to our pizza store, we launch an offer for customers, where they can buy one item and get the second for free. To do this, we create a method called onePlusOneOffer, which accepts some restaurant parameter. Before the launch of Swift 5.7, this feature wasn’t available, so let’s thank the Swift gods 😆

This method will accept any type that conforms to RestaurantItem. Once this is done, we can just print the output of acceptOrderItem and prepareOrderItem twice within a loop. Additionally, we also increase the order number and print the order start and order complete messages.

The pizza shop also needs another method that can accept a happy meal-like combo that includes a pizza, a side dish, and a drink in one order. It should also be able to create a custom order of any combination of restaurant items. To do this, we create a single method called mealOrder. This method will accept an array of any RestaurantItem. This capability was also not present before Swift 5.7.

Within this method, we can also loop through the array and print the acceptOrderItem and PrepareOrderItem messages.

The third new feature in Generics as part of Swift 5.7 allows the compiler to unwrap the concrete type from any abstract type definition and call the correct concrete type implementation. Thus, we can print the start and end of the order while increasing the orderNumber property.

https://gist.github.com/SahilMutualMobile/970ec5be8e973874854e588131fbbc18

Client usage

Now, we’ll create two constants of any RestaurantItem array for the happy meals. We instantiate PizzaShop class and call the mealOrder method and pass the happy meal constants or any custom order array.

And, when we call the onePlusOneOffer method and pass an order for any item in the parameter, we can get one extra item with each item ordered.

https://gist.github.com/SahilMutualMobile/c561be825267746e4209a1088ed514bb

The bottom line

With the aforementioned updates to Generics in Swift 5.7, quite a few limitations have been lifted, making it more relevant and usable in Swift codebases.

Now, you can go forth and make Generics prosper in Swift using these features. Just don’t use our pizza shop example 😆

The story around Swift doesn’t end here, as we conclude the Swift series with an exciting sneak peek into the intriguing world of SwiftUI charts, so stay tuned!

Swift II — WWDC 2022 heralding a new dawn for Generics? was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.

One is faster to build but tougher to maintain. The other is slower to build but cheaper to maintain. But which is the best bet for your business?

Smartphones are the most personal devices we have today.‍

Double-checking your pocket. Controlling your home with it. Connecting, playing, earning. All roads lead back to that slab of glass and silicon nestled in your pocket.

On a device that’s so personal, you can’t afford to waste your time with sloppy interfaces and buggy apps. It ruins the idea of smartphones for most users — especially Google’s next billion users for whom the devices may become unapproachable.

That’s why designing the right experience for apps installed on a device is so crucial.

It isn’t just about App Store or Play Store ratings — it’s about setting a direction for the future of every user’s experience.‍

So when an onus of such magnitude rests on a stressed developer or business owner trying to make the right decisions for their company’s app, the choices among the multiple platforms that await them can get overwhelming.

That’s exactly what we had in mind when we developed this quick-and-easy guide to understanding the advantages and disadvantages of hybrid and native apps.

What are native and hybrid apps?

Native apps are written in your device’s OS languages: Objective-C/Swift for iOS and Java/Kotlin for Android. Hybrid apps are websites dressed like apps with quite a few pros and cons. For instance, they work across iOS and Android but suffer in overall build quality and compatibility.‍

What are the advantages of hybrid apps?

Despite their issues, hybrid apps have a few perks:

• A shared codebase devs can maintain across platforms.
• Larger dev community that contributes to open frameworks.
• HTML-friendly base allows them to handle APIs and the backend better.
• An application developed once is done forever across multiple platforms.‍

The disadvantages of hybrid apps over native apps

Design language

Google’s Material Design changed the game for Android apps. Its clear hierarchies and creative user interface guidelines moved Android away from a one-size-fits-all approach and closer to iOS’s Human Interface Guidelines (HIG) system. Moreover, each device uses its own browser to render the hybrid app’s web elements.‍

High maintenance costs

All hybrid apps still need bridges between native operations and their HTML-based processes. Although there are plug-and-play hooks out there with programming languages like Flutter, React Native, Xamarin, and Ionic, these usually lag behind native OS releases. This inflates maintenance costs and threatens to capsize the product’s development lifecycle.‍

Lack of reliable support

Hybrid libraries aren’t the best when it comes to supporting third-party SDKs. And it’s the same the other way round. The HTML elements in hybrid apps power its functionality and interaction within a native wrapper — making regular support updates a complex maneuver. ‍

Performance issues

Granted hybrid apps have come a long way in looking and working like native apps. But the app gets increasingly more unstable as its feature list grows. Moreover, hybrid apps are hugely dependent on internet connectivity and a web browser. They struggle to live up to performance mandates when offline.‍

Hybrid apps in the long run

On the whole, hybrid apps cost more than custom ones in the long run. And that’s without the native-like responsiveness mobile platform users seek today.

Lower upfront costs are offset by higher development costs later in the life cycle. Granted, hybrid apps are easier to get off the ground. But they’re just as hard to keep up in the air.

The fast start and early wins hybrid apps afford devs in the beginning of the lifecycle give way to bottlenecks and development manholes later on.‍

What are the advantages of native apps?

Designed to fit your device’s OS to the last pixel, native apps offer a huge performance and UX leap over hybrid apps. They also keep costs stable, the life cycle predictable, and updates regular. All to a vastly greater degree than hybrid apps.

In fact, in the case of most enterprise apps, native apps end up costing less than hybrid apps in the long run, thanks to more predictable development lifecycles.

Largely, their advantages are:‍

Richer UX

Native apps match the OS down to the last pixel. They run directly on top of the OS. Native apps extract more from the hardware and optimize resources a lot better. The resulting user experience is smooth and cohesive–with apps that feel well integrated with one’s device.‍

Maximum hardware performance

Native apps also afford users better hardware functionality than hybrid apps. It harnesses a smartphone’s resources more efficiently and rides comfortably atop the OS. This ensures the user’s experience isn’t marred by crashes, connectivity issues, and random errors–all huge factors in boosting user retention.‍

Cheaper to maintain

OS updates are ridiculously easy to apply to native apps. In fact, most of your native app’s updates can be handled quietly in the backend–making for a seamless user experience. And when businesses factor in the ease of maintenance with native apps, they find them cheaper than hybrid apps in the long run.‍

Unbeatable app access

Everything from the device’s camera, microphone, calendar, GPS, fingerprint sensors, and motion sensors work perfectly with native apps. Users can hop and skip their way through the app without pausing to let it load and work.‍

Verdict: Native apps or hybrid apps?

For every business looking to build a user-centric app, there simply is no competition on the hybrid front.

Native apps offer a smoother experience for both businesses and their customers.

In fact, you are more likely to spend time fixing and tweaking the app because of user complaints about UI elements and performance driven issues when working with a hybrid app.

Although native apps have larger upfront costs, they end up saving you more money in the long run while offering an unbeatable user experience and an industry standard app performance.‍

Our verdict: Native apps win over hybrid apps.

Native vs Hybrid Apps: Who’s the Loser? | Mutual Mobile was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.

Remember about the ‘ANARCHIC’ future we discussed recently? You know, where we spoke about developers, app aesthetics, and app security.

Well, this would prevent you from even imagining that alternate universe (or what if its multiverse scenario?) Okay, enough jokes 😛

So, how?

As promised (we didn’t solemnly swear, but still 😛), we’re back with the sequel to the biometric authentication in Android.

And this time, cryptography joins the bandwagon of enhancing app security.
‍

But first, what is cryptography? It is a technique used to secure sensitive data with algorithms that helps ensure the authenticity of data, which cannot be accessed without a secret key. This helps in preventing unauthorized users from reading the encrypted data.

So now, since you know what’s cryptography, let’s get our hands dirty with the AndroidX Biometric API and cryptography.

‍

AndroidX Biometric API and Cryptography

As we mentioned in the first article of this series, the AndroidX Biometric API is a comprehensive solution for handling biometric authentication in Android applications. This API authenticates users with the help of biometrics and device credentials.

Another key aspect of this API is that it includes an exciting feature known as CryptoObject, which can be used to incorporate cryptography in the authentication flow. The AndroidX Biometric API supports cryptographic solutions like Signature, Cipher, and Mac. Here, we’ll be focusing on Cipher.
‍

After successful authentication with the biometric prompt, we can further enhance app security with a cryptographic operation. How, you ask?

By using a SecretKey object to perform encryption and decryption while authenticating with the Cipher object.

So, let’s see how biometric authentication and cryptography work together in an Android framework.‍

Cryptography and key management

As mentioned above, a cryptography-based authentication can be carried out using a Cipher object that enables the encryption and decryption of data. To use Cipher, we have to generate a SecretKey. This key can be used by authorized personnel to protect the data.

In the Android ecosystem, these keys are stored in the KeyStore. This does the job of storing these keys at secure locations.

In case, an app requests the SecretKey, the KeyStore provides an alias of the key, instead of the actual SecretKey itself. Only the KeyStore is capable of providing an alias of the SecretKey, which helps in boosting reliability and security.

When the app wants to encrypt data, the KeyStore does that using the alias while providing us with the ciphertext, which is basically the encrypted data. The same also takes place when the app wants to decrypt the encrypted data.

Here’s how it takes place:

fun generateSecretKey(keyGenParams: KeyGenParameterSpec) {
    val keyGenerator = KeyGenerator.getInstance(
            KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
    keyGenerator.init(keyGenParams)
    keyGenerator.generateKey()
}

fun getSecretKey(): SecretKey {
    val keyStore = KeyStore.getInstance("AndroidKeyStore")

    // keyStore must be loaded before accessing it.
    keyStore.load(null)
    return keyStore.getKey(KEY_NAME, null) as SecretKey
}

fun getCipher(): Cipher {
    return Cipher.getInstance(KeyProperties.KEY_ALGORITHM_AES + "/"
            + KeyProperties.BLOCK_MODE_CBC + "/"
            + KeyProperties.ENCRYPTION_PADDING_PKCS7)
}

Authenticating using only biometric credentials

If an app uses a SecretKey that needs biometric credentials to unlock, users have to authenticate their biometric credentials every time before the app accesses the SecretKey.

Here’s how to enable this with a few steps.

Step 1

Generate a key using the KeyGenParameterSpec configuration, we use a builder for that:

fun getKeyGenParams(): KeyGenParameterSpec {
return KeyGenParameterSpec.Builder(
        KEY_NAME,
        KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
        .setBlockModes(KeyProperties.BLOCK_MODE_CBC)
        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_PKCS7)
        .setUserAuthenticationRequired(true)
        // Invalidate the keys if the user has registered a new biometric
        // credential, such as a new fingerprint.
        .setInvalidatedByBiometricEnrollment(true)
        .build()
}‍

Step 2

Start the biometric authentication workflow using a cipher:

fun authenticateToEncrypt() {
    val cipher = getCipher()
    val secretKey = getSecretKey()
    cipher.init(Cipher.ENCRYPT_MODE, secretKey)
    biometricPrompt.authenticate(promptInfo,
            BiometricPrompt.CryptoObject(cipher))
}‍

Step 3

Use the SecretKey to encrypt the sensitive data inside biometric authentication callbacks:

override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
    val cipher = result.cryptoObject?.cipher
    val plainText = "Some data to encrypt"
    val encryptedInfo: ByteArray =cipher?.doFinal(
      plaintext.toByteArray(Charset.defaultCharset())
    )
    Log.d("TAG", "Encrypted information: " +  Arrays.toString(encryptedInfo))
}‍

Authenticating using biometric or lock screen credentials

If an app uses a SecretKey that needs biometric or lock screen credentials (password, pattern, or PIN) to unlock, then a validity time period must be specified. This validity allows the app to perform multiple cryptographic operations without re-authenticating the user.

To use this type of key, we have to add a fallback to non-biometric credentials. Hence, we cannot pass an instance of CryptoObject in the authenticate() function of the BiometricPrompt.

Here’s how this type of authentication takes place.

Step 1

Generate a key using the KeyGenParameterSpec configuration:

val keyGenParams = KeyGenParameterSpec.Builder(
            KEY_NAME,
            KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
            .setBlockModes(KeyProperties.BLOCK_MODE_CBC)
            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_PKCS7)
            .setUserAuthenticationRequired(true)
            .setUserAuthenticationParameters(
                 VALIDITY_DURATION_IN_SECONDS, ALLOWED_AUTHENTICATORS
         )
        .build()

‍

Step 2

Encrypt the sensitive information within a time span of VALIDITY_DURATION_SECONDS after the user authenticates successfully:

fun encryptSensitiveData() {
    val cipher = getCipher()
    val secretKey = getSecretKey()
    try {
        cipher.init(Cipher.ENCRYPT_MODE, secretKey)
        val encryptedInfo: ByteArray = cipher.doFinal(
                plaintext-string.toByteArray(Charset.defaultCharset()))
        Log.d("TAG", "Encrypted information: " + Arrays.toString(encryptedInfo))
    } catch (e: InvalidKeyException) {
        Log.e("TAG", "Key is invalid.")
    } catch (e: UserNotAuthenticatedException) {
        Log.d("TAG", "The key's validity timed out.")
        biometricPrompt.authenticate(promptInfo)
    }

To add the aforementioned callback, we can mention that the app supports device credentials by including DEVICE_CREDENTIAL into the set of values passed for setAllowedAuthenticators().‍

Authenticating using auth-per-use keys

Users also have the option to integrate auth-per-keys within the instance of the BiometricPrompt. Auth-per-keys are secret keys that are used to perform a single cryptographic operation. For example, if you have to carry out 5 cryptographic operations, you’ll need 5 auth-per-keys.

Due to its immense security benefits, auth-per-keys offer exciting use cases such as making large payments or updating transaction statement records.

To incorporate an auth-per-key within the BiometricPrompt, we can generate the following KeyGenParameterSpec configuration:

val authPerUseKeyGenParams =
        KeyGenParameterSpec.Builder("myKeystoreAlias", key-purpose)
    // Accept either a device credential or a biometric credential.
    // To accept only one type of credential, include only that type as the second argument.
    .setUserAuthenticationParameters(0 /* duration */,
            KeyProperties.AUTH_BIOMETRIC_STRONG or
            KeyProperties.AUTH_DEVICE_CREDENTIAL)
    .build()

Authenticating without explicit user interaction

In some cases, users might not need to confirm the authentication process. Here, the users can interact with the app more quickly after re-authenticating using face or fingerprint recognition.

To implement this, pass false into the setConfirmationRequired() function in PromptInfo Builder.

fun getBiometricPromptInfo(
    title: String = "Biometric login",
    subtitle: String = "Log in using your biometric credential",
    negativeButtonText = "Use account password",
isConfirmationRequired = false
): BiometricPrompt.PromptInfo {

  val builder = BiometricPrompt.PromptInfo.Builder()
      .setTitle(title)
      .setSubtitle(subtitle)
      .setNegativeButtonText(negativeButtonText)
      .setConfirmationRequired(isConfirmationRequired)
  return builder.build()
}

And that’s how you can build a passwordless secure solution for authentication using BiometricPrompt and cryptography.

With passwordless solutions getting all the attention in recent times, stay tuned for our take on this exciting and potentially game-changing trend!

Biometric authentication with cryptography in Android | Mutual Mobile was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.

How would the future look if app developers only focused on making sure apps were aesthetically pleasing and fun to use, without complete regard for app security?

ANARCHIC!‍

Hence, it is crucial for developers to also focus carefully on enhancing app security along with user productivity. One of the most secure manners of boosting app security and safeguarding user data is with the help of biometric authentication, such as facial or fingerprint recognition.‍

Biometric authentication with AndroidX Biometric API

Biometric authentication allows users to unlock their mobile devices using fingerprint or facial recognition. This helps in ensuring that the right person is accessing the mobile device.

Now, let’s explore biometric authentication in Android using an API (application programming interface).

AndroidX Biometric API is a comprehensive solution for handling biometric authentication in Android applications. This API authenticates users with the help of biometrics and device credentials, while performing cryptographic operations. This API can be integrated easily into any Android project by adding it as a dependency.

Here’s how it can be done in the build.gradle file of your app module:

dependencies {
…
    implementation "androidx.biometric:biometric-ktx:1.2.0-alpha04"
…
}‍

Features of AndroidX Biometric API

• Analyses if a device possesses biometric authentication capabilities.
• Provides a standard biometric prompt for facial or fingerprint recognition.
• Provides callbacks for failed or successful authentication attempts.
• Provides choices for pins, passwords, or patterns, in case you do not want to opt for biometric credentials.‍

AndroidX Biometric API and device capability

Since the AndroidX Biometric API is relatively new and not all devices possess biometric capabilities, it becomes necessary to check if a particular device is capable. The following extension function can be used to check biometric authentication capabilities:

fun Context.isBiometricCapable() : Int {
   val biometricManager = BiometricManager.from(this)
   biometricManager.canAuthenticate()
}

In this above scenario, we created a BiometricManager using the provided context that would assist canAuthenticate() in determining whether the hardware has biometric authentication capabilities.

In some cases, devices may possess the requisite hardware for biometric authentication, but this BiometricPrompt can only be employed if users have registered their biometric information in their devices’ security settings.

Moving on, if the canAuthenticate() is implemented, it will return the following results:

• BIOMETRIC_SUCCESS: The device is ready to use a biometric prompt, implying the device is compatible with biometric software, and the user has added their biometric data to the device’s settings.
• BIOMETRIC_ERROR_NONE_ENROLLED: The device supports biometrics, but the user has not added their facial or fingerprint data.
• BIOMETRIC_ERROR_NO_HARDWARE: The device hardware is not capable of biometric authentication.
• BIOMETRIC_ERROR_HW_UNAVAILABLE: Biometric features are currently unavailable.‍

Types of authentications in AndroidX Biometric API

Once you have completed the authentication process, you can check the authentication type by calling getAuthenticationType() to see if the user has authenticated using a device or biometric credential.

In this case, the getAuthenticationType() will provide the following results:

• AUTHENTICATION_RESULT_TYPE_UNKNOWN: The authentication type is unknown.
• AUTHENTICATION_RESULT_TYPE_DEVICE_CREDENTIAL: The user has authenticated using device credentials.
• AUTHENTICATION_RESULT_TYPE_BIOMETRIC: The user has authenticated using device biometric authentication.

Building the biometric login prompt

Once we have determined that the user’s device has been authenticated, we can display a default system prompt requesting the user to authenticate using biometric credentials. This system-generated prompt is consistent across the apps that use it, thus creating a seamless user experience.

Here’s how you can show the login prompt:

• First, use PromptInfo to configure the desired messages and actions.
• Then, Activity and Callback Handlers are used to initialize the BiometricPrompt
  ‍

Step 1

The PromptInfo is developed using a builder class, BiometricPrompt.PromptInfo.Builder, which also populates it with the title, subtitle, and description.

fun getBiometricPromptInfo(
    title: String,
    subtitle: String,
    description: String
): BiometricPrompt.PromptInfo {

  val builder = BiometricPrompt.PromptInfo.Builder()
      .setTitle(title)
      .setSubtitle(subtitle)
      .setDescription(description)

  return builder.build()
}‍

Step 2

Now, you can initialize the BiometricPrompt and handle the callbacks with a custom listener from the calling activity.

fun initBiometricPrompt(
    activity: AppCompatActivity,
    listener: BiometricAuthListener
): BiometricPrompt {
  val executor = ContextCompat.getMainExecutor(activity)

  val callback = object : BiometricPrompt.AuthenticationCallback() {
    
      override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
         super.onAuthenticationError(errorCode, errString)
         listener.onBiometricAuthenticationError(errorCode, errString.toString())
     }

    override fun onAuthenticationFailed() {
      super.onAuthenticationFailed()
      Log.w(this.javaClass.simpleName, "Authentication failed for an unknown reason")
    }

    override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
      super.onAuthenticationSucceeded(result)
      listener.onBiometricAuthenticationSuccess(result)
    }
  }

  return BiometricPrompt(activity, executor, callback)
}

What does the above code snippet in Android achieve? It creates an executor to handle callback events and the callback object to obtain authentication events on Error, Failed, or Success. Then it updates custom listener methods with results and error messages. Finally, it returns a biometric prompt using the activity instance, executor, and callback reference.

You might be now wondering how to display the biometric prompt. Here’s how it’s done:

• First, we need to setBiometricPromptInfo() by passing the title, subtitle, and description.
• Then we need to initialize the BiometricPrompt using initBiometricPrompt() by passing calling Activity Instance and custom callback listener instance.
• And finally, we show the prompt using the authenticate method by passing promptInfo biometricPrompt.authenticate(promptInfo).

fun initBiometricPrompt() {

val promptInfo = getBiometricPromptInfo(title, subtitle, description) 
val biometricPrompt = initBiometricPrompt(this, biometricAuthListener) 

biometricPrompt.authenticate(promptInfo)

}

And that is how you can build a biometric passwordless solution using BiometricPrompt. Now, isn’t that awesome?

You also can further boost app security and sensitive data (and yes, we thought it best to surprise you with this 😆). So, now, coming to the question on your mind, how to boost app security even after biometric authentication? Well, the answer is adding cryptography to the biometric authentication workflow. But, good things take time, so keep a lookout for the sequel to biometric authentication in Android!

Biometric authentication in Android | Mutual Mobile was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.

Can today’s IoT (Internet of Things) devices get any smarter? Probably. Smart IoT is a rapidly growing branch that uses artificial intelligence to mimic human-like decision making. But is it something we really need? We voice our opinion.

The Internet of Things (IoT) dates its story back to Carnegie Mellon University in 1982. A humble Coca-Cola vending machine (which goes on to describe its experience) attained the rare distinction of being the first ever IoT device when it connected to the ARPANET (Advanced Research Projects Agency Network).

ARPANET was the first ever wide-area packet-switched (a method your local internet provider uses even today) network and one of the first few to implement the TCP/IP protocol. All this was to make sure the poor vending machine reported its inventory and if new drinks were cold or not.

But IoT came to the fore with the rise of the smartphone after the iPhone debuted in 2007. Cisco reports that the things/people ratio grew from 0.08 in 2003 to 1.84 by 2010! The technology is so ubiquitous today that most of us don’t even realize we’re using it.

That begs the question…‍

What is the Internet of Things?

Let’s start with your home.

What if your devices could talk to each other through the internet to be a little smarter and make your life a lot easier?

Garden sprinklers that talk to your weather app and adjust water supply based on its information. Coffee makers that link to your alarm clock and have a piping hot Americano ready by the time you dawdle into the kitchen.

A connected system of hardworking microcontrollers, actuators, and sensors works in tandem with communication hardware like WiFi and Bluetooth to make an IoT network, well, work.

Works like a charm, no?

Not really.‍

Why IoT isn’t perfect yet

While devices talk to each other and act together with more knowledge, they still lack perception. Their understanding of any situation is confined to a single layer. You can trust them to be mature enough to act with spontaneity when circumstances change rapidly. In other words, today’s IoT enables devices to only perform an action in response to feedback, not modify it.

Consider a home automation system where your lights, air conditioners, and thermostats track your movement to know they should switch on. Once they notice your lack of activity, they assume that you’re absent and turn themselves off.

But, even a system as clever as this breaks in the face of something as prosaic as sleep. When you’re asleep, the devices notice your lack of movement, assume it indicates your absence, and promptly turn themselves off. It’s good IoT, but dumb execution.

Cognitive artificial intelligence (AI) makes such systems smarter by letting them perceive. Cognitive AI would take a few initial inputs from you and keep the system in line with your preferences without bothering you for constant, untimely inputs.

To paint a clearer picture, let’s step into the office of Microsoft’s Chief Scientist, Eric Horvitz.‍

How Eric made his office smarter

At the Redmond research lab that houses Microsoft’s AI researchers, Eric built an IoT system to handle visitors to the office. Strong AI powers his system to enable devices to perceive, learn, and reason. Together, they make it easier for visitors to find him and free up his human assistant to do more productive work.

Once you enter the ground floor lobby, a camera and computer immediately notice you. They calculate your direction, pace, and distance to make a prediction that ensures you have an elevator waiting for you.

A robot greets you and asks if you need help locating Eric when you get off. As you reach him, a virtual personal assistant anticipates your arrival, checks Eric’s schedule, and asks if you’d like to be seated until Eric frees up.

Although this entire chain of smart IoT devices received initial training (Eric built this in 2014, by the way), it used cognitive AI to collect data and learn on its own independent of programmers. For example, it taught itself how to react when you pause in the hallway to answer a phone call or pick up a pen.

In other words, cognitive AI teaches smart IoT systems to learn from real-time data and optimize themselves for better performance. However…

What exactly is cognitive AI?

As the Turing Archive defines it, traditional AI is the science of making computers do things that require intelligence when done by humans. It augments human capacity. But cognitive AI replicates human capacity.

It does this by modeling itself on the functioning and decision-making of the human brain. It analyzes and validates data to decide without human intervention. Built-in self-learning methodologies such as data mining and pattern recognition make this system flexible enough to adapt with changes in data.

An everyday example of this is smart assistants like Siri and Alexa. They use Natural Language Processing (NLP) as well as cognitive AI to mimic human behavior and make leaps of logic to solve complex problems. Just like a human being, cognitive AI can reason, compare, and decide, which is the closest we can get to programming imagination into them.

Eric’s case above may come across initially as hyper-niche. But it isn’t. There’s a lot to extrapolate and explore in there, with some of it already in practice within smart buildings and smart cities.‍

Windows, roofs, and AI: How smart buildings work

Ealy smart buildings used an IoT system to collect data from sensors. The building could then use this to save costs because devices would know when to switch themselves off. But, IoT systems typically rely on a boolean rule to manage devices, which often means they could react in ways that are completely out of sync with the situation.

Cognitive AI will improve this by collecting equipment data from IoT sensors, tagging it by location or asset type, checking against business rules, and triggering algorithms that detect and respond to anomalies.

AI is handy with real-time data analytics, drawing inferences, and allowing predictive maintenance. A recent development in the field is AI-powered hotdesking, where the building’s virtual assistant monitors available desk spaces (and even conference rooms) to let you know which ones are free to use.‍

Concrete, signals, and AI: How smart cities work

A smart city does what it does by collecting data from mass urban settings, like important squares, avenues, and traffic stops. For instance, a smart city could collect real-time air quality data and study it to build improvement models. This would help usher in practical civic action and data-based politics.

The same logic would extend to tracking water use, energy supplies, supply chain logistics, and empowering cognitive AI-powered IoT systems to gradually optimize the system with each passing day. An example would be Bill Gates’ proposed new smart city in Arizona, where he bought $80 million worth of land to start building.‍

Do I need smart IoT?

Smart IoT has endless possibilities. From saving costs at home to trimming expenses at workplaces, sites, and factories, smart IoT can do wonders for your business. In fact, you can schedule a free one-on-one consultation with one of our specialists to understand if your business can even benefit from smart IoT.

So if you’re looking to make your business smarter, hit us up here. Our team would love to brainstorm with you. Perhaps, the next big thing is just one conversation away from you and us?

What is smart IoT and how it works | Mutual Mobile was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.

Imagine if you were a human. Wait, did we just ask you to ‘imagine if you were a human’ 🤦

That’s on us, so let’s start this from the top.

Imagine if you were a vampire, werewolf, dragon, unicorn, mermaid, leprechaun, or even Nessie, the Loch Ness monster. Would you rather shop digitally or go the old-school way?‍

Okay, fiiiiine, we’ll stop this fun/tedious charade (dealer’s choice), and get to the point.

Digital purchases are on the rise!‍

Are you wondering how we came to such a declaration?

Well, a whopping 86% of buyers (humans, not mythical creatures) prefer social media, metaverse, and virtual purchases over face-to-face sales. That’s how 😛‍

The convenience and efficiency make them attractive to customers since they can acquire items instantly, albeit in a virtual space. To keep up with the cutthroat competition, brands are aggressively expanding their product and service lines in the form of digital products such as online courses, software solutions, and graphic design templates. With this increased cutthroat competition, brands are having to come up with unique methods to make their digital products stand out and attract consumers.‍

So, the big question here is how can brands do that? And only one answer comes to mind — the product discovery process.‍

Introduction to the product discovery process

The product discovery process is a phase wherein research is conducted to collate and collect detailed insights and information that would be used for creating digital products. This phase helps brands develop products that are essential, and not just nice to have.

In this phase, a product’s usability is ascertained and how consumers would perceive it. Some key aspects of the product discovery process include determining the final objective, setting the target audience, product functionality, and UX/UI design.

The research conducted in this phase is also vital for determining how to make the product stand out from the competition and whether the market is ready for such a product.‍

Importance of the product discovery process

Ensures product launch success and reduces risk

How much do companies spend on R&D? Well, according to Inc Magazine, it’s estimated at 23% of a company’s budget. But, depending on the outcome of a product, this expenditure could prove to be highly successful or a waste of money.

For example, Quibi was a mobile-focused streaming service launched in 2018. However, it was a massive failure, and the company was dissolved in 2020. Such instances can be avoided with a comprehensive and detailed product discovery process.‍

Keeps digital development on track

This product discovery process provides insights to companies about how their products can add value to consumers. Research methods such as journey maps and user analysis act as guides in the product development phase. They can also be used during the development process to ensure the product features add value to consumers and are synced with the company objectives. This helps reduce hesitancy towards implementing the product discovery process while keeping the digital development on track for success.‍

How to create a successful product discovery process

Several key aspects must be carried out to ensure a successful discovery process. The first of them is to pay close attention to market trends. This helps the company understand what digital services are in demand, which markets to consider, and how to enter said markets successfully.

Some of these market trends include data analytics and social media. Observing what people are sharing online and examining posts with high engagement gives an idea about the ongoing trends. You can also conduct polls on social media to understand consumers’ preferences and tastes. You could also shadow the social media platforms of digital product companies like Netflix, Canva, and Salesforce to get an insight into the latest trends.

Secondly, data gathered from consumers’ habits can also help anticipate trends. For example, previous purchases can give an insight into what consumers might purchase next. The best tool to carry this out is Google Analytics. It provides you with customer behavior analysis, which can be used to understand how consumers respond to your products and what products they gravitate towards the most.

Apart from market trends and data, you should regularly conduct competitor analysis to stay above them. For instance, in the online education space, Udemy has the edge over Coursera since it gives more importance to skill development rather than accredited programs. And that’s precisely the reason why consumers opt for Udemy over Coursera.

This shows how valuable the product discovery process can be in your armor if used correctly, and we can help you pull it off with our award-winning team.

The importance of discovery in building a great digital product | Mutual Mobile was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.

What if mobile apps never existed? Can you even fathom such a reality?

Thankfully, we don’t even have to imagine such an alternate reality (*shivers*), since, today, there is an app for every possible requirement. Running out of groceries? Now, there are apps that deliver those directly to your doorstep in 15 minutes flat. Want a fresh set of prescription medicines? Put your feet up and relax at home while those are delivered to you. And of course, then there’s Amazon, that’s got you covered for technology, furniture, books, clothes, and more.

This growing dependency and the necessity of apps have led to massive growth in the app development industry. In fact, global revenue from mobile apps is expected to rise to $613 billion by 2025, up from $318 billion in 2020. This has also increased the competition to develop engaging, robust, and successful applications.

Keeping this increased competition in mind, there are numerous factors that you must consider when developing your app. One such key factor is the app development framework, which becomes even more critical for startups. Flutter is an app development framework that is considered to be an excellent choice for startups to drive business growth.

Here, we will delve deeper into the world of Flutter and why it is the best option for startups.‍

What is Flutter?

Flutter is an open-source app development framework used for building beautiful cross-platform applications. It’s written in Dart and launched in 2017 by Google. As mentioned, it offers cross-platform development and can be used to create robust apps for Android, iOS, Linux, macOS, Windows, and the web using a single codebase. Furthermore, points continue to stack up in favor of Flutter, since it is the most popular cross-platform app development framework.‍

Why is Flutter the ideal framework for startups?

Easy to learn

Flutter became the toast of the town within a short time of its launch. Why, you ask? Due to its benefits of ease of learning and effortless accessibility.

Flutter provides developers with excellent in-depth documentation on the best practices for using it. Moreover, Flutter includes video tutorials on its website, which makes it easier for novices to understand the basics of the app development framework.‍

Cross-platform development

One of the most striking features of Flutter is that it allows you to create cross-platform apps for multiple platforms from a single codebase. Unlike other app development frameworks, it doesn’t require separate codebases for different operating systems.

Writing separate codebases for apps across different operating systems can be cumbersome and tedious. Here’s where Flutter provides a significant advantage while helping save time and money, and reducing developers’ workloads.‍

Hot reload

Hot reload in Flutter is a handy and quick function that allows developers to fix bugs, create UIs, add features, and apply code changes instantly. Hence, developers can update codes at any point and view the changes instantly without restarting the entire program. Moreover, developers get to use this feature in Flutter since it’s written in Dart, which allows them to experiment with unique user interfaces.‍

Better performance

Apps built using Flutter are considered to perform better than those built using other frameworks, making it ideal for startups. The ahead-of-time compilation feature allows programmers to compile their Dart code into machine language ahead of time, i.e., in build time instead of run time, thus making the app feel native.

Usually, in other cross-platform frameworks, the compilation of codebase to machine language is done in run-time, which takes a significant amount of time, thus reducing performance.‍

Budget-friendly and free-to-use plugins

Flutter is open-sourced and free-to-use, thus not requiring licensing fees. In addition, it also provides plugins and packages. One of them being Firebase Cloud Messaging (FCM). FCM is a free cross-platform plugin and messaging solution for notifications and messages on Android, iOS, and the web.‍

Wrapping up

Considering the benefits mentioned above, it’s no surprise that Flutter has become developers’ go-to cross-platform app development framework. This also applies to startups since they have limited funds and resources, and Flutter provides them with the tools and services necessary to succeed in a cutthroat app development environment.

Flutter for startups: What you should know | Mutual Mobile was originally published in Mutual Mobile on Medium, where people are continuing the conversation by highlighting and responding to this story.