Stories by Vivek JM on Medium

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1nlAV1CDQ5aTV488gFUdwA.jpeg"></figure>Mobile apps are no longer a futuristic vision; they’re deeply woven into our daily routines, from ordering groceries with a few taps to staying connected with friends across continents. But amidst the hype, it’s important to ground ourselves in reality, exploring the trends that will truly shape the future of mobile experiences.
<h3>Beyond Buzzwords: Trends with Substance (and Stats)</h3>
<ol>
<li>
Hyper-Personalization Takes Center Stage: Forget generic experiences. The global AI market value is projected to exceed $126 billion by 2025, fueling AI and machine learning in apps. Imagine an app that predicts your workout preferences (Statista, 2023) or curates news feeds based on your individual interests (Accenture, 2022).</li>
<li>
Niche Apps Thrive: Move over, super apps. The mobile app market will see a surge in niche solutions, catering to specific needs and interests. This aligns with the 68% of consumers who prefer personalized experiences (PwC, 2022). Imagine a fitness app for your unique sport, a language app tailored to your regional dialect, or a productivity tool designed for your profession.</li>
<li>
AI, Your Invisible Assistant: AI won’t just be a fancy feature; it’ll become your embedded daily companion. By 2025, 80% of enterprises will be using AI (Gartner, 2021). Imagine voice-controlled smart home integration through your app, automated financial management, or real-time language translation — all within familiar interfaces.</li>
<li>
No-Code Democratizes App Creation: Coding will no longer be a barrier. No-code and low-code platforms will empower anyone to build basic apps, fostering innovation and accessibility. The no-code market is expected to reach $26.8 billion by 2027 (MarketsandMarkets, 2023). Imagine schools building interactive learning tools, businesses creating custom loyalty programs, or communities developing communication hubs — all without needing technical expertise.</li>
<li>
Blurring the Lines: AR &amp; VR Take Center Stage: The physical and digital realms will converge. The global AR/VR market will reach $320 billion by 2027 (Grand View Research, 2022). Imagine trying on clothes virtually (reducing returns by 85%, ThredUp, 2021), learning complex concepts with interactive AR lessons, or attending immersive business meetings in VR spaces.</li>
</ol>
It’s Not Just About Technology:
Let’s remember, technology is just a tool. The real value lies in how it improves our lives. As developers and users, we must prioritize:
<ul>
<li>
User-centric Design: Focus on solving real problems, offering intuitive interfaces, and ensuring accessibility for all. 73% of users abandon apps with poor usability (App Annie, 2022).</li>
<li>
Privacy and Security: Robust security measures are crucial in a data-sensitive world. 83% of users are concerned about data privacy (IBM, 2022).</li>
<li>
Ethical Considerations: Consider the potential impact of your app on society, from AI biases to the environmental footprint of technology.</li>
</ul>
The Future is Open:
The mobile app landscape is dynamic and ever-evolving. Embrace the exciting possibilities, but remember, the real magic lies in using technology to create a better, more equitable world for everyone.
Now, it’s your turn! What trends are you most excited about? What challenges do you see? Share your thoughts in the comments below!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=227a1b8682d5" width="1" height="1" alt="">

Beyond Hype: Unveiling the Real Future of Mobile Apps

The surge in mobile app popularity is fuelled by shifting user preferences and the demand for convenient interactions. App installs have increased by 31% annually, with user engagement rising by 4.5%. The Apple App Store boasts 2.22 million apps, while Google Play features 3.48 million. Consumers, embracing 5G and post-pandemic behaviours, seek convenience in shopping, delivery, gaming, and fitness apps.
Businesses, both B2B and B2C, prfioritize mobile interactions to meet evolving consumer expectations. Seamless mobile experiences are crucial as organisations adapt to changing behaviours. In 2024, understanding mobile app architecture is paramount for capitalising on the mobile revolution’s opportunities.
<h3>Mobile Application Architecture ? Lets dive deep !</h3>
Mobile app architecture encompasses a structured framework of rules, techniques, processes, and patterns essential for the development of mobile applications. These guidelines empower developers to craft apps that align with business objectives while adhering to industry standards.
Mobile App Architecture vs. Mobile Tech Stack: What’s the Difference?
Mobile app architecture is often mistakenly equated with the mobile tech stack. However, this comparison overlooks the nuanced differences between the two. While the mobile technology stack pertains to the assortment of technologies and technical frameworks constituting the front and back-end of a mobile or web app (dealing with the functionality and structure of the app), it places less emphasis on the business or customer requirements (the rationale behind the app) and the development process (the methodologies employed in creating the app).
Conversely, mobile app architecture encompasses a broader spectrum of considerations, encompassing the purpose, content, and technical implementation of the app. It encompasses aspects such as data collection, data flow, app design, target platforms, and the chosen tech stack, serving as the blueprint for the app’s development and functionality.
Characteristics of a Strong Mobile App Architecture
Developing mobile apps without adhering to architecture standards can lead to:
1. Increased development time and costs. 2. Maintenance difficulties, especially with staff turnover. 3. Limited scalability and expansion potential. 4. Challenges in testing and higher error rates.
A robust mobile app architecture integrates essential software development principles like KISS, DRY, and SOLID. It:
1. Streamlines development processes. 2. Facilitates clear data flow. 3. Supports future scalability and expansion. 4. Promotes flexibility and aligns with Agile development practices. 5. Enhances testing efficiency and simplifies future maintenance. 6. Reduces the risk of bugs. 7. Should be platform-agnostic, catering to both native and cross-platform development approaches for a unified strategy.
Thinking of mobile app architecture as a skeleton, it provides the framework for building essential components, ensuring consistency and coherence throughout the app development process.
<h3>Layers in Mobile App Architecture</h3>
Mobile app architecture is categorised by 3 layers: presentation, business logic, and data.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gG_7zAoyyUJlrQBcerAL8A.png"></figure>1)Presentation Layer The presentation layer encompasses all processes and components responsible for delivering the app to the user. Developers focus on what users see and experience when interacting with the app. This layer consists of the User Interface (UI) and User Experience (UX).
UI involves design elements such as colors, fonts, placement, and overall aesthetic. UX involves managing how users interact with the app based on their needs and emotions.
When designing the presentation layer, developers must choose the appropriate platform and device type to ensure consistency with each platform’s standards.
2)Business Layer The business layer handles the logic and rules governing data exchange, operations, and workflow regulation. Its responsibilities include:
1. Ensuring security 2. Implementing data caching 3. Managing logging 4. Performing data validation 5. Handling exception management
The placement of the business layer can vary, residing either on the server or the user device, depending on the app’s operations and resource requirements.
3)Data Layer
The data layer encompasses data utilities, service agents, and data access components essential for facilitating data transactions. It can be divided into two components:
1. Persistence: Facilitating data access with data sources via APIs. 2. Network: Handling network communication, routing, and error reporting.
The design of the data layer should consider validation and maintenance of the data to ensure its accuracy and integrity.
<h3>Android Mobile Application Architecture</h3>
Android apps, which are designed specifically for the Android platform, represent a type of native app tailored to a particular mobile operating system. These apps are developed to support languages such as Kotlin and Java, catering to devices manufactured by various companies like Google, Samsung, Sony, and Nokia. Although there isn’t a single prescribed architecture for Android apps, Clean Architecture is widely embraced within the Android development community.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M57XwCwZvxwtOV9V0Yk94Q.png"><figcaption>Clean Architecture</figcaption></figure>Clean Architecture is structured around the principles of layers and inversion of control. It adopts a three-layered structure, with the business layer often referred to as the domain layer. In Clean Architecture, it’s crucial that the domain or business layer remains independent of the other layers and instead relies on interfaces. While this concept may pose challenges in comprehension, it greatly facilitates the scalability and extensibility of apps over time.
<h3>iOS Mobile Application Architecture</h3>
Native iOS apps are built using Objective-C and Swift programming languages, with Apple advocating clear best practices for app architecture through the Model-View-Controller (MVC) model. The MVC model comprises:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Aso7s2Mh5wM8AIr37zo1Yg.png"><figcaption>MVC architecture</figcaption></figure>1. Model: This represents the data layer, including components such as persistence, model objects, parsers, managers, and networking code. 2. View: Similar to the presentation layer, the view is a reusable component that presents the app’s interface to the user. 3. Controller: Acting as a mediator, the controller communicates with an abstraction through a protocol.
The MVC model facilitates rapid and parallel development and offers the flexibility to create multiple views, making it an excellent choice for mobile development on the iOS platform.
<h3>Hybrid Mobile Application Architecture</h3>
Hybrid mobile applications combine the strengths of both native and web technologies. They utilize native frameworks for backend functionalities while employing platform-independent JavaScript, HTML, and CSS for the frontend. To access native platform features, hybrid apps integrate plugins like Apache Cordova or Ionic Capacitor.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-ssyMjEX_QpnI73GKbnGIg.png"><figcaption>Hybrid Architecture</figcaption></figure>Hybrid mobile apps offer rapid development and easy updates across multiple platforms. However, they may not be suitable for intricate or highly interactive applications due to their inherent limitations.
Cross platform apps benefits
Cross-platform development, similar to hybrid architecture, utilizes a shared codebase with platform-specific functionalities within native shells. Instead of web languages, cross-platform apps employ frameworks like React Native and Xamarin. They aim to provide a user experience closer to native apps, which often enhances their appeal.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G8gKxEoGdB_-nCPide2Ocw.png"><figcaption>Cross platform benefits</figcaption></figure><h4>Factors to Consider When Developing Mobile App Architecture?</h4>
1. Device Considerations When embarking on mobile app design, the primary step involves selecting the platform (iOS, iPadOS, Android, Windows, Cross-platform) and understanding the diverse range of smartphone models in use. Key factors such as screen size, DPI, resolution, CPU, and RAM must be taken into account to determine optimal development dimensions. The aim is to ensure a consistent user experience across various platforms and device types (e.g., tablets vs. mobiles, different model variations).
2. Development Frameworks In crafting mobile app architecture and establishing the tech stack, the choice of developmental frameworks is crucial. These frameworks offer libraries, templates, and components for both front-end and back-end development. Front-end options include Bootstrap, Foundation, React, Angular, Vue, and Backbone, while back-end frameworks vary based on programming language and target platforms such as Ruby on Rails, Flask, Django, Laravel, Swift, Xamarin, React Native, and Flutter, among others.
3. Bandwidth Considerations Understanding user research insights is paramount, especially considering the varying bandwidth scenarios worldwide. From countries with advanced 5G networks to those with intermittent connectivity, it’s vital to tailor app features accordingly. For instance, highly interactive or graphic-heavy apps may not suit users in rural areas with limited bandwidth.
4. User Interface/User Experience (UI/UX) Design UI/UX design significantly influences initial impressions and user retention in mobile app architecture. A robust UX design aligns with evolving user expectations and OS/device-specific best practices. Balancing UI aesthetics with UX functionality is crucial, emphasizing the importance of staying informed about mobile UX design basics and emerging trends for 2024.
5. Navigation Strategies Navigation serves as the primary point of interaction between users and the design, influencing both front-end and back-end elements. A well-designed mobile UX enables users to easily navigate pages and explore different sections. Familiarity is key in navigation, and employing the following best practices can enhance user experience and reduce friction in the customer journey:
1. Hamburger Menu: Utilize the three-line menu in the navigation drawer or top bar, a popular choice due to its familiarity. Enhance navigation further with hover-over menus to reduce clicks.
2. Search Bar: Position the search bar effectively, typically at the top right, to improve usability and accessibility.
3. Navigation Options: Explore various navigation structures such as fixed bars of buttons (top and/or bottom), vertical rails, hidden drawers, and fixed tabs with titles for streamlined navigation.
4. Familiar Icons: Incorporate recognizable icons like home, search, photos, and folders to facilitate navigation and improve user understanding.
5. Intuitive Labeling: Clearly label buttons, options, and features to provide users with clear intent and guidance.
6. Site Organization: Organize content logically to simplify navigation, adhering to information architecture best practices for enhanced user experience.
7. Gesture Support: Implement gesture-based navigation, such as swiping, to streamline user interactions and navigation within the app.
8. Scrolling Behavior: Ensure smooth scrolling and consider how the app supports scroll versus fixed elements to optimize user experience.
9. Thumb Zone Navigation: Design with the thumb zone in mind to improve usability, considering the natural reach of users’ thumbs for comfortable navigation.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n9ig_NqYWqyx74c1PgwfiA.png"></figure>5. Push Notifications vs Real-time Updates
Balancing user engagement and annoyance is crucial when considering notification frequency and method, as it also impacts device battery life and, consequently, user retention.
Mobile push notifications serve as messages that apps send to inform users about new in-app content or messages, whether from the app itself (e.g., product updates, offers, reminders) or other users. While Android users are automatically opted in for push notifications, iOS users must opt-in, typically at a lower rate (51% iOS vs. 81% Android).
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cYI9p-bKBCQ-VJWZMm0txg.png"></figure>Although some may find them bothersome, push notifications can effectively serve as a marketing tool, especially when personalized or conveying urgency.
In addition to scheduled push notifications, mobile apps are increasingly integrating real-time technologies for enhanced interactivity. For instance, a delivery app can utilize real-time updates to inform users about order status, tracked on a live map from acceptance to delivery. Similarly, health and fitness apps or home technologies benefit from real-time alerts, such as security system notifications. However, it’s essential to use real-time updates judiciously to prevent overwhelming users with notifications.
<h3>How to Choose the Right Mobile App Architecture?</h3>
Considerations for Finalizing Mobile Product Design Architecture:
1. Budget: The selection of architecture is influenced by factors such as developer expertise, market analysis, and development methodology. However, the demand for rapid development often exceeds the availability of skilled IT professionals, potentially rendering an app obsolete before its market debut.
2. Audience Analysis: Understanding user demographics, personas, and needs is essential. Conduct competitive analysis, develop agile user stories, map user flows, create wireframes, and conduct prototype testing to refine the design.
3. Key Feature Requirements: Align business requirements with feature lists to determine the most suitable development approach — Native, Hybrid, or Cross-Platform.
4. Platform Selection: Tailor UI and UX design practices to the specific platform, considering the unique characteristics of each.
5. Development Time: Certain architectures may require more time for specific elements or integrations. Factor development timelines into the overall plan and decision-making process.
6. Initiate Test App Development: Adopt an agile development approach, emphasizing iterative development and continuous feedback. Develop a basic test app with essential functionality and navigation to gather valuable user insights and ensure the architecture meets user expectations.
<h3>Conclusion</h3>
In the realm of mobile app development, crafting a robust design architecture is paramount for success. It involves careful consideration of factors like budget, audience analysis, key features, platform selection, and development time. By prioritizing user-centricity and embracing iterative refinement through the development of test apps, we ensure that our architectural choices resonate with user needs and expectations, paving the way for innovative and impactful mobile experiences.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=9645da914b06" width="1" height="1" alt="">

Navigating the Depths of Mobile Architecture: A Comprehensive Guide

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yYijQwVU2aB8ftp2kxpdpg.png"></figure>Animations play an important role in mobile apps by giving life into the process of interaction and are especially good for mobile apps that have to be developed with limited screen estate, while providing an informative and functional interface.
Commonly used method in building interactive animations in react native is by using Animated api,that covers our most of the animation use cases and scenarios such as duration-based animation or spring or decay animation and APIs for canceling animation or repeat and interpolation
Problem arises while using the core animated api is that animated Api uses the JS thread for the calculating the animated values and if the js thread is busy running a complex business logic then the frame drops can occur at massive rate that destroys the overall animation experience and interactions
<h3>Why Reanimated ?</h3>
Reanimated saves us from the frame drop hell in react native,reanimated solves this very problem, by allowing us to run animation natively on the UI thread and thus eliminating any kind of delays.
Version 2 of the package, or what came to be known as reanimated 2 in the community, provides us with a set of useful hooks and functions allowing us to write cleaner code, less boilerplate and using plain JavaScript instead of the library’s own functions compared to the first version.
More details about working of the package can be found in <a href="https://docs.swmansion.com/react-native-reanimated/docs#motivation">official doc</a>
<h4>Lets dive deep into key concepts of reanimated 2</h4>
In part 1 of the article we will be looking at the important hooks that came along with the version 2 of reanimated and in the end we will be building a simple animation using the learned concepts
<ol><li>Worklets</li></ol>
Worklets are simple javascript functions that run completely on UI thread,The only thing that is needed is for that function to have “worklet” directive at the top.. Each worklet function can be run either on the main React Native thread if you just call that function in your code, or you can execute it on the UI thread using runOnUI
<pre>function someWorklet(greeting) { 'worklet'; console.log(greeting, 'From the UI thread'); }</pre>
<pre>function onPress() { runOnUI(someWorklet)('Howdy'); }</pre>
2. Shared Values
Shared Values are among fundamental concepts behind Reanimated 2.0, similar to that of Animated.values from react natives animated Api.They serve a similar purpose of carrying “animateable” data, providing a notion of reactiveness, and driving animations.In order to create a Shared Value reference, you should use useSharedValue hook.
<pre>import Animated, { useSharedValue, useAnimatedScrollHandler, } from 'react-native-reanimated';</pre>
<pre>function SomeComponent({ children }) { const scrollOffset = useSharedValue(0);</pre>
<pre>const scrollHandler = useAnimatedScrollHandler({ onScroll: (event) =&gt; { scrollOffset.value = event.contentOffset.y; }, });</pre>
<pre>return ( &lt;Animated.ScrollView onScroll={scrollHandler}&gt; {children} &lt;/Animated.ScrollView&gt; ); }</pre>
From the example given above from the official docs we can see that ,the scroll handler is a worklet and runs the scroll event logic on the UI thread. and the Updates made in that worklets are synchronous.
3. useAnimatedStyle
Allows us to create an association between shared values and View properties,arguments for the hooks are updater(function)and dependencies(array) that returns Animated style — in order to connect the animated style hook result, you need to pass it as one of the style properties to the Animated version of the component (e.g. Animated.View).
<pre>const App = () =&gt; { const [state, setState] = useState(0); const sv = useSharedValue(state);</pre>
<pre>const style = useAnimatedStyle(() =&gt; { return { width: sv.value, }; }, dependencies); //... return &lt;&gt;&lt;/&gt;; };</pre>
4. useDerivedValue
Allows us for creating shared value reference that can change in response to updating of one or more other shared values.arguments for the hooks are updater(function)and dependencies(array) that returns a reference to a shared value initialized with the provided data. The reference is an object with .value property, that can be accessed and modified from worklets, but also updated directly from the main JS thread.
<pre>import { Button } from 'react-native'; import { useSharedValue, useDerivedValue } from 'react-native-reanimated';</pre>
<pre>function App() { const progress = useSharedValue(0); const width = useDerivedValue(() =&gt; { return progress.value * 250; });</pre>
<pre>return ( &lt;View&gt; &lt;SomeComponent width={width} /&gt; &lt;Button onPress={() =&gt; (progress.value = Math.random())} /&gt; &lt;/View&gt; ); }</pre>
Now lets implement a simple reanimated animation using the learned concepts
<a href="https://medium.com/media/42aea96b7ea4d9a7a2b4815ad9131c29/href">https://medium.com/media/42aea96b7ea4d9a7a2b4815ad9131c29/href</a>In the above example we used withRepeat hook to repeat an animation several time and which then changes the style of the view using the animated style hook that returns a new style object for new values and then we used a worklet to calculate the shape for the transformed object that runs completely on the UI thread that results the animation given below
<figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*H6TspJWbKBZg8cfs7p39Qw.gif"><figcaption>Example for worklet animation</figcaption></figure><h3>Conclusion</h3>
That’s pretty much everything about the basics of the reanimated from my perspective and i will keep exploring on this awesome library done by softwaremansion
More details about animation hooks provided by reanimated will be covered in the Part 2 of this article with some awesome cool animations that run on UI thread
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=b7668db4ecf5" width="1" height="1" alt="">

Getting started with Reanimated 2 for React native Part-1

<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*Fv5h19Fz4CSbMzriPHoUTA.gif"></figure>Code push is a Microsoft appcenter service that helps you to change your application’s code, release it, and have your users get the new version almost immediately. It doesn’t require the end-user to upgrade to a new version from the app store.
It’s important to remember that there are certain limitations for the code push upgrade ,only the JavaScript bundle can be altered with the service and all the native functionalities need to be released with the traditional store updates.
Without further delay let’s implement the code push in our app in simple steps:
<h4>1) Install the appcenter CLI and code push CLI for react-native</h4>
<pre>npm install -g appcenter-cli npm install --save react-native-code-push</pre>
<h4>2) Simply wrap the root component of the app with a HOC from code push</h4>
<a href="https://medium.com/media/f096392eaaa58eedb20badd753a6a1cf/href">https://medium.com/media/f096392eaaa58eedb20badd753a6a1cf/href</a><h4>3) Next , go to the appcenter and create a new application for android and iOS platforms.</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t6uq7NZYiGnemljx-Aid7A.png"></figure>Once the app has been created ,the app will list the number of steps to integrate the SDK for corresponding platforms . Follow the below steps for the SDK integrations
<h4>IOS SDK Integration</h4>
<ol>
<li>Run cd ios &amp;&amp; pod install &amp;&amp; cd .. to install all the necessary CocoaPods dependencies.</li>
<li>Open up the AppDelegate.m file, and add an import statement for the CodePush headers</li>
</ol>
<pre>#import &lt;CodePush/CodePush.h&gt;</pre>
3. Find the following line of code, that sets the source URL for bridging the production releases:
<pre>return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];</pre>
4. Replace it with this line:
<pre>return [CodePush bundleURL];</pre>
5. sourceURLForBridge method should look like this:
<pre>- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge { #if DEBUG return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index" fallbackResource:nil]; #else return [CodePush bundleURL]; #endif }</pre>
6. Add the Deployment key to Info.plist: To let the CodePush runtime know which deployment it should query for updates against, open your app's Info.plist file and add a new entry named CodePushDeploymentKey, these keys can be found under the distribute section in app center.
<h4>Android SDK Integration</h4>
<ol><li>In your android/settings.gradle file, make the following additions:</li></ol>
<pre>include ':app', ':react-native-code-push' project(':react-native-code-push').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-code-push/android/app')</pre>
2. In your android/app/build.gradle file, add the codepush.gradle file as an additional build task definition underneath react.gradle:
<pre>... apply from: "../../node_modules/react-native/react.gradle" apply from: "../../node_modules/react-native-code-push/android/codepush.gradle" ...</pre>
3. Update the MainApplication.java file to use CodePush via the following changes:
<pre>... // 1. Import the plugin class. import com.microsoft.codepush.react.CodePush; public class MainApplication extends Application implements ReactApplication { private final ReactNativeHost mReactNativeHost = new ReactNativeHost(this) { ... // 2. Override the getJSBundleFile method to let // the CodePush runtime determine where to get the JS // bundle location from on each app start <a href="http://twitter.com/Override">@Override</a> protected String getJSBundleFile() { return CodePush.getJSBundleFile(); } }; }</pre>
4. Add the Deployment key to strings.xml:
To let the CodePush runtime know which deployment it should query for updates, open your app’s strings.xml file and add a new string named CodePushDeploymentKey
<pre>&lt;resources&gt; &lt;string name="app_name"&gt;AppName&lt;/string&gt; &lt;string moduleConfig="true" name="CodePushDeploymentKey"&gt;DeploymentKey&lt;/string&gt; &lt;/resources&gt;</pre>
<h4>4) Releasing Updates</h4>
Once your app is configured and distributed to your users, and you have made some JS or asset changes, it’s time to release them. The recommended way to release them is using the release-react command in the CodePush CLI, which bundles your JavaScript files, asset files, and release the update to the CodePush server.
<pre>appcenter codepush release-react -a &lt;ownerName&gt;/&lt;appName&gt;</pre>
<pre>appcenter codepush release-react -a &lt;ownerName&gt;/MyApp-iOS appcenter codepush release-react -a &lt;ownerName&gt;/MyApp-Android</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wsAq4rYSglsqjym8_gJ7hQ.png"></figure><h3>Wrapping up</h3>
CodePush gives you plenty of room when it comes to fixing bugs and making code changes. It provides great flexibility for handling code updates and gives you control over when to install them. That being said, it also adds another dimension of complexity when it comes to the native side.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=a38e07d294ce" width="1" height="1" alt="">

Vivek Jm.

I specialize in developing mobile experiences.

UX and Full Stack

Recent Projects

Credzy

Build Connect

Happilee

City Weekly

Head Coach

Vibeonix

Urban Chat

Synopsis

About Me

Technologies I love to build with

Reasearch and planning

Informative

Recent Articles