<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Nagajothy - Mobile Application Developer on Medium]]></title>
        <description><![CDATA[Stories by Nagajothy - Mobile Application Developer on Medium]]></description>
        <link>https://medium.com/@nagajothyklearn?source=rss-428d00a2eee6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*VORDluIf59i7DpRr</url>
            <title>Stories by Nagajothy - Mobile Application Developer on Medium</title>
            <link>https://medium.com/@nagajothyklearn?source=rss-428d00a2eee6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 05:26:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nagajothyklearn/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[SOLID Pr]]></title>
            <link>https://medium.com/@nagajothyklearn/solid-pr-8c9dcdc1949f?source=rss-428d00a2eee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c9dcdc1949f</guid>
            <dc:creator><![CDATA[Nagajothy - Mobile Application Developer]]></dc:creator>
            <pubDate>Wed, 19 Nov 2025 12:36:14 GMT</pubDate>
            <atom:updated>2025-11-19T12:36:14.759Z</atom:updated>
            <content:encoded><![CDATA[<h3>SOLID Principles</h3><p>SOLID Principles:</p><p>Definition and purpose</p><p>Solid is an acronym for five design principles intended to make software understandable, maintainable, scalable, testable.</p><p>Types</p><p>Single Responsibility Principle</p><p>Open/Closed Principle</p><p>Liskov Substitution Principle</p><p>Interface Segregation Principle</p><p>Dependency Inversion Principle</p><p>Scope</p><p>Applies to class and module design in object oriented programming Languages.</p><p>Single Responsibility Principle</p><p>A class should have only one reason to change ,meaning it should have only one job or repsonsibility.</p><p>Food Delievery Example</p><pre>// ❌ VIOLATION - RestaurantManager doing too many things<br>class RestaurantManager {<br>    fun validateRestaurant(restaurant: Restaurant) {<br>        // Validation logic<br>    }<br>    <br>    fun saveToDatabase(restaurant: Restaurant) {<br>        // Database operations<br>    }<br>    <br>    fun uploadRestaurantImages(images: List&lt;Image&gt;) {<br>        // Image upload logic<br>    }<br>    <br>    fun sendWelcomeEmail(restaurant: Restaurant) {<br>        // Email sending logic<br>    }<br>    <br>    fun calculateCommission(restaurant: Restaurant) {<br>        // Commission calculation<br>    }<br>}<br><br>// ✅ FOLLOWING SRP - Each class has single responsibility<br>class RestaurantValidator {<br>    fun validate(restaurant: Restaurant): ValidationResult {<br>        return if (restaurant.name.isBlank()) {<br>            ValidationResult.Error(&quot;Restaurant name cannot be empty&quot;)<br>        } else if (restaurant.address.isBlank()) {<br>            ValidationResult.Error(&quot;Address cannot be empty&quot;)<br>        } else {<br>            ValidationResult.Success<br>        }<br>    }<br>}<br><br>class RestaurantRepository {<br>    suspend fun saveRestaurant(restaurant: Restaurant) {<br>        // Only database operations<br>        restaurantDao.insert(restaurant)<br>    }<br>    <br>    suspend fun getRestaurant(id: String): Restaurant? {<br>        return restaurantDao.getById(id)<br>    }<br>}<br><br>class ImageUploadService {<br>    suspend fun uploadImages(images: List&lt;Image&gt;): List&lt;String&gt; {<br>        // Only image upload logic<br>        return images.map { uploadSingleImage(it) }<br>    }<br>    <br>    private suspend fun uploadSingleImage(image: Image): String {<br>        // Upload to cloud storage and return URL<br>        return &quot;https://cloudstorage.com/images/${image.id}&quot;<br>    }<br>}<br><br>class EmailService {<br>    fun sendWelcomeEmail(restaurant: Restaurant) {<br>        // Only email sending logic<br>        val emailContent = buildWelcomeEmail(restaurant)<br>        emailClient.send(restaurant.email, emailContent)<br>    }<br>}<br><br>class CommissionCalculator {<br>    fun calculateCommission(orders: List&lt;Order&gt;): Money {<br>        // Only commission calculation<br>        return orders.sumOf { it.total * COMMISSION_RATE }<br>    }<br>}</pre><h3>Why SRP Matters in Food Delivery:</h3><p>RestaurantValidator can be tested independently.</p><p>ImageUploadService can be replaced without affecting other services.</p><p>Easier to maintain and debug specific functionality</p><p>Open/Closed Principle(OCD)</p><p>Software entities should be open for extendable but closed for modifications</p><p>Food Delievery Example:</p><pre>// ❌ VIOLATION - Adding new discount types requires modifying existing class<br>class DiscountCalculator {<br>    fun calculateDiscount(order: Order, discountType: String): Money {<br>        return when (discountType) {<br>            &quot;PERCENTAGE&quot; -&gt; order.total * 0.1<br>            &quot;FIXED_AMOUNT&quot; -&gt; Money(100.0)<br>            &quot;BUY_ONE_GET_ONE&quot; -&gt; calculateBOGODiscount(order)<br>            &quot;FESTIVAL&quot; -&gt; calculateFestivalDiscount(order) // New type requires modification<br>            else -&gt; Money(0.0)<br>        }<br>    }<br>}<br><br>// ✅ FOLLOWING OCP - Open for extension, closed for modification<br>interface DiscountStrategy {<br>    fun calculateDiscount(order: Order): Money<br>}<br><br>class PercentageDiscount(private val percentage: Double) : DiscountStrategy {<br>    override fun calculateDiscount(order: Order): Money {<br>        return order.total * (percentage / 100)<br>    }<br>}<br><br>class FixedAmountDiscount(private val amount: Money) : DiscountStrategy {<br>    override fun calculateDiscount(order: Order): Money {<br>        return amount<br>    }<br>}<br><br>class BuyOneGetOneDiscount : DiscountStrategy {<br>    override fun calculateDiscount(order: Order): Money {<br>        // BOGO logic<br>        return order.items<br>            .filter { it.isEligibleForBOGO }<br>            .sumOf { it.price }<br>    }<br>}<br><br>// NEW DISCOUNT TYPE - No modification to existing classes<br>class FestivalDiscount(private val festival: Festival) : DiscountStrategy {<br>    override fun calculateDiscount(order: Order): Money {<br>        return when (festival) {<br>            Festival.DIWALI -&gt; order.total * 0.15<br>            Festival.CHRISTMAS -&gt; order.total * 0.12<br>            Festival.NEW_YEAR -&gt; Money(50.0)<br>        }<br>    }<br>}<br><br>class DiscountCalculator(private val strategies: List&lt;DiscountStrategy&gt;) {<br>    fun calculateBestDiscount(order: Order): Money {<br>        return strategies.maxOfOrNull { it.calculateDiscount(order) } ?: Money(0.0)<br>    }<br>}<br><br>// Usage in Order Service<br>class OrderService {<br>    private val discountCalculator = DiscountCalculator(<br>        listOf(<br>            PercentageDiscount(10.0),<br>            FixedAmountDiscount(Money(100.0)),<br>            BuyOneGetOneDiscount(),<br>            FestivalDiscount(Festival.DIWALI) // Easy to add new strategies<br>        )<br>    )<br>    <br>    fun processOrder(order: Order) {<br>        val discount = discountCalculator.calculateBestDiscount(order)<br>        order.applyDiscount(discount)<br>    }<br>}</pre><h3>Why OCP Matters in Food Delivery:</h3><ul><li>Easy to add seasonal discounts (Diwali, Christmas)</li><li>Can introduce partner-specific discounts without changing core logic</li><li>Marketing team can experiment with new discount types safely</li></ul><p>LisKov Subsititution Principle(LSP)</p><p>Objects of a superclass should be replaceable with objects of its subclasses without breaking the application.</p><p>Food Delievery Example:</p><pre>// ❌ VIOLATION - Subclasses break parent contract<br>open class PaymentMethod {<br>    open fun processPayment(amount: Money): Boolean {<br>        // Base implementation<br>        return true<br>    }<br>    <br>    open fun refundPayment(transactionId: String): Boolean {<br>        // Base refund logic<br>        return true<br>    }<br>}<br><br>class CreditCardPayment : PaymentMethod() {<br>    override fun processPayment(amount: Money): Boolean {<br>        if (amount &gt; Money(10000.0)) {<br>            throw Exception(&quot;Credit card limit exceeded&quot;) // Violates LSP - parent doesn&#39;t throw<br>        }<br>        return super.processPayment(amount)<br>    }<br>}<br><br>class CashOnDelivery : PaymentMethod() {<br>    override fun refundPayment(transactionId: String): Boolean {<br>        throw UnsupportedOperationException(&quot;COD cannot be refunded&quot;) // Violates LSP<br>    }<br>}<br><br>// ✅ FOLLOWING LSP - Subclasses can substitute parent without issues<br>interface PaymentMethod {<br>    fun processPayment(amount: Money): PaymentResult<br>    fun canRefund(): Boolean<br>    fun refundPayment(transactionId: String): RefundResult<br>}<br><br>class CreditCardPayment : PaymentMethod {<br>    override fun processPayment(amount: Money): PaymentResult {<br>        return if (amount &gt; Money(10000.0)) {<br>            PaymentResult.Failed(&quot;Amount exceeds credit limit&quot;)<br>        } else {<br>            // Process payment<br>            PaymentResult.Success(&quot;TXN_123&quot;)<br>        }<br>    }<br>    <br>    override fun canRefund(): Boolean = true<br>    <br>    override fun refundPayment(transactionId: String): RefundResult {<br>        // Process refund<br>        return RefundResult.Success<br>    }<br>}<br><br>class CashOnDelivery : PaymentMethod {<br>    override fun processPayment(amount: Money): PaymentResult {<br>        // COD - no immediate payment processing<br>        return PaymentResult.Success(&quot;COD_ORDER&quot;)<br>    }<br>    <br>    override fun canRefund(): Boolean = false<br>    <br>    override fun refundPayment(transactionId: String): RefundResult {<br>        return RefundResult.Failed(&quot;Refund not supported for COD&quot;)<br>    }<br>}<br><br>class UpiPayment : PaymentMethod {<br>    override fun processPayment(amount: Money): PaymentResult {<br>        // UPI payment logic<br>        return PaymentResult.Success(&quot;UPI_TXN_456&quot;)<br>    }<br>    <br>    override fun canRefund(): Boolean = true<br>    <br>    override fun refundPayment(transactionId: String): RefundResult {<br>        // UPI refund logic<br>        return RefundResult.Success<br>    }<br>}<br><br>// Payment Processor - can use any PaymentMethod interchangeably<br>class PaymentProcessor {<br>    fun processOrderPayment(order: Order, paymentMethod: PaymentMethod) {<br>        val result = paymentMethod.processPayment(order.total)<br>        <br>        when (result) {<br>            is PaymentResult.Success -&gt; {<br>                order.confirmPayment(result.transactionId)<br>                sendPaymentConfirmation(order)<br>            }<br>            is PaymentResult.Failed -&gt; {<br>                order.markPaymentFailed(result.reason)<br>                notifyPaymentFailure(order, result.reason)<br>            }<br>        }<br>    }<br>    <br>    fun refundOrder(order: Order, paymentMethod: PaymentMethod) {<br>        if (paymentMethod.canRefund()) {<br>            val refundResult = paymentMethod.refundPayment(order.transactionId)<br>            handleRefundResult(refundResult)<br>        } else {<br>            notifyManualRefundRequired(order)<br>        }<br>    }<br>}</pre><h3>Why LSP Matters in Food Delivery:</h3><ul><li>Can add new payment methods (PayPal, Crypto) without breaking existing code</li><li>Payment processing works consistently across all methods</li><li>Easy to test payment flows with different methods</li></ul><p>Interface Segregation Principle(ISP)</p><p>Clients should not be forced to depend on interfaces they don’t use.</p><pre>// ❌ VIOLATION - Fat interface forcing implementations to provide empty methods<br>interface RestaurantOperations {<br>    fun addMenuItem(item: MenuItem)<br>    fun updateMenuItem(item: MenuItem)<br>    fun deleteMenuItem(itemId: String)<br>    fun processOrder(order: Order)<br>    fun cancelOrder(order: Order)<br>    fun generateReports(): List&lt;Report&gt;<br>    fun manageStaff(staff: Staff)<br>    fun updateRestaurantInfo(info: RestaurantInfo)<br>}<br><br>class CustomerApp : RestaurantOperations {<br>    // Customer doesn&#39;t need most of these operations<br>    override fun addMenuItem(item: MenuItem) {<br>        throw UnsupportedOperationException(&quot;Customers cannot add menu items&quot;)<br>    }<br>    <br>    override fun updateMenuItem(item: MenuItem) {<br>        throw UnsupportedOperationException(&quot;Customers cannot update menu items&quot;)<br>    }<br>    <br>    // ... many empty/unimplemented methods<br>}<br><br>// ✅ FOLLOWING ISP - Segregated interfaces based on client needs<br>interface CustomerOperations {<br>    fun browseMenu(restaurantId: String): List&lt;MenuItem&gt;<br>    fun placeOrder(order: Order): OrderResult<br>    fun trackOrder(orderId: String): OrderStatus<br>    fun cancelOrder(order: Order): CancelResult<br>}<br><br>interface RestaurantAdminOperations {<br>    fun addMenuItem(item: MenuItem)<br>    fun updateMenuItem(item: MenuItem)<br>    fun deleteMenuItem(itemId: String)<br>    fun updateRestaurantInfo(info: RestaurantInfo)<br>}<br><br>interface RestaurantStaffOperations {<br>    fun viewOrders(): List&lt;Order&gt;<br>    fun processOrder(order: Order)<br>    fun updateOrderStatus(orderId: String, status: OrderStatus)<br>}<br><br>interface ReportingOperations {<br>    fun generateSalesReport(): SalesReport<br>    fun generateCustomerReport(): CustomerReport<br>    fun generateInventoryReport(): InventoryReport<br>}<br><br>// Client implementations - only depend on what they need<br>class CustomerApp : CustomerOperations {<br>    override fun browseMenu(restaurantId: String): List&lt;MenuItem&gt; {<br>        return menuRepository.getMenu(restaurantId)<br>    }<br>    <br>    override fun placeOrder(order: Order): OrderResult {<br>        return orderService.placeOrder(order)<br>    }<br>    <br>    override fun trackOrder(orderId: String): OrderStatus {<br>        return orderService.getOrderStatus(orderId)<br>    }<br>    <br>    override fun cancelOrder(order: Order): CancelResult {<br>        return orderService.cancelOrder(order.id)<br>    }<br>}<br><br>class RestaurantAdminApp : RestaurantAdminOperations, ReportingOperations {<br>    override fun addMenuItem(item: MenuItem) {<br>        menuRepository.addItem(item)<br>    }<br>    <br>    override fun updateMenuItem(item: MenuItem) {<br>        menuRepository.updateItem(item)<br>    }<br>    <br>    override fun deleteMenuItem(itemId: String) {<br>        menuRepository.deleteItem(itemId)<br>    }<br>    <br>    override fun updateRestaurantInfo(info: RestaurantInfo) {<br>        restaurantRepository.updateInfo(info)<br>    }<br>    <br>    override fun generateSalesReport(): SalesReport {<br>        return reportGenerator.generateSalesReport()<br>    }<br>    <br>    override fun generateCustomerReport(): CustomerReport {<br>        return reportGenerator.generateCustomerReport()<br>    }<br>    <br>    override fun generateInventoryReport(): InventoryReport {<br>        return reportGenerator.generateInventoryReport()<br>    }<br>}<br><br>class DeliveryPartnerApp : RestaurantStaffOperations {<br>    override fun viewOrders(): List&lt;Order&gt; {<br>        return orderService.getAssignedOrders()<br>    }<br>    <br>    override fun processOrder(order: Order) {<br>        orderService.processOrder(order.id)<br>    }<br>    <br>    override fun updateOrderStatus(orderId: String, status: OrderStatus) {<br>        orderService.updateStatus(orderId, status)<br>    }<br>}</pre><h3>Why ISP Matters in Food Delivery:</h3><ul><li>Customer app doesn’t get bloated with admin features</li><li>Delivery partner app has focused functionality</li><li>Easier to maintain and update specific client apps</li></ul><p>Dependency Inversion Principle (DIP)</p><p>High-level modules should not depend on low-level modules. Both should depend on abstractions.</p><pre>// ❌ VIOLATION - High-level modules depend on low-level implementations<br>class OrderService {<br>    private val databaseRepository = DatabaseOrderRepository() // Direct dependency<br>    private val emailNotifier = EmailNotificationService() // Direct dependency<br>    private val paymentProcessor = StripePaymentProcessor() // Direct dependency<br>    <br>    fun processOrder(order: Order) {<br>        databaseRepository.save(order)<br>        paymentProcessor.charge(order.total)<br>        emailNotifier.sendOrderConfirmation(order)<br>    }<br>}<br><br>class DatabaseOrderRepository {<br>    fun save(order: Order) {<br>        // Direct database access<br>    }<br>}<br><br>class EmailNotificationService {<br>    fun sendOrderConfirmation(order: Order) {<br>        // Direct email service access<br>    }<br>}<br><br>// ✅ FOLLOWING DIP - Depend on abstractions, not concretions<br>interface OrderRepository {<br>    suspend fun saveOrder(order: Order): Order<br>    suspend fun findOrder(id: String): Order?<br>    suspend fun updateOrder(order: Order): Order<br>}<br><br>interface NotificationService {<br>    suspend fun sendOrderConfirmation(order: Order)<br>    suspend fun sendOrderStatusUpdate(order: Order, status: OrderStatus)<br>    suspend fun sendDeliveryUpdate(order: Order, delivery: DeliveryInfo)<br>}<br><br>interface PaymentProcessor {<br>    suspend fun processPayment(amount: Money, paymentMethod: PaymentMethod): PaymentResult<br>    suspend fun refundPayment(transactionId: String): RefundResult<br>}<br><br>// High-level module depends on abstractions<br>class OrderService(<br>    private val orderRepository: OrderRepository,<br>    private val notificationService: NotificationService,<br>    private val paymentProcessor: PaymentProcessor<br>) {<br>    suspend fun processOrder(order: Order): OrderResult {<br>        return try {<br>            // Process payment<br>            val paymentResult = paymentProcessor.processPayment(order.total, order.paymentMethod)<br>            <br>            if (paymentResult is PaymentResult.Success) {<br>                // Save order<br>                val savedOrder = orderRepository.saveOrder(<br>                    order.copy(transactionId = paymentResult.transactionId)<br>                )<br>                <br>                // Send notification<br>                notificationService.sendOrderConfirmation(savedOrder)<br>                <br>                OrderResult.Success(savedOrder)<br>            } else {<br>                OrderResult.PaymentFailed(paymentResult.reason)<br>            }<br>        } catch (e: Exception) {<br>            OrderResult.Error(e.message ?: &quot;Unknown error&quot;)<br>        }<br>    }<br>}<br><br>// Low-level implementations depend on same abstractions<br>class DatabaseOrderRepository : OrderRepository {<br>    override suspend fun saveOrder(order: Order): Order {<br>        return orderDao.insert(order)<br>    }<br>    <br>    override suspend fun findOrder(id: String): Order? {<br>        return orderDao.getById(id)<br>    }<br>    <br>    override suspend fun updateOrder(order: Order): Order {<br>        return orderDao.update(order)<br>    }<br>}<br><br>class FirebaseOrderRepository : OrderRepository {<br>    override suspend fun saveOrder(order: Order): Order {<br>        // Save to Firebase<br>        return firestore.collection(&quot;orders&quot;).add(order).get().toObject(Order::class.java)<br>    }<br>    <br>    override suspend fun findOrder(id: String): Order? {<br>        return firestore.collection(&quot;orders&quot;).document(id).get().toObject(Order::class.java)<br>    }<br>    <br>    override suspend fun updateOrder(order: Order): Order {<br>        return firestore.collection(&quot;orders&quot;).document(order.id).set(order).get().toObject(Order::class.java)<br>    }<br>}<br><br>class EmailNotificationService : NotificationService {<br>    override suspend fun sendOrderConfirmation(order: Order) {<br>        emailClient.send(order.customerEmail, buildConfirmationEmail(order))<br>    }<br>    <br>    override suspend fun sendOrderStatusUpdate(order: Order, status: OrderStatus) {<br>        emailClient.send(order.customerEmail, buildStatusEmail(order, status))<br>    }<br>    <br>    override suspend fun sendDeliveryUpdate(order: Order, delivery: DeliveryInfo) {<br>        emailClient.send(order.customerEmail, buildDeliveryEmail(order, delivery))<br>    }<br>}<br><br>class PushNotificationService : NotificationService {<br>    override suspend fun sendOrderConfirmation(order: Order) {<br>        pushNotificationClient.send(<br>            order.customerId, <br>            &quot;Order Confirmed&quot;, <br>            &quot;Your order #${order.id} has been confirmed&quot;<br>        )<br>    }<br>    <br>    override suspend fun sendOrderStatusUpdate(order: Order, status: OrderStatus) {<br>        pushNotificationClient.send(<br>            order.customerId,<br>            &quot;Order Update&quot;,<br>            &quot;Your order is now ${status.name}&quot;<br>        )<br>    }<br>    <br>    override suspend fun sendDeliveryUpdate(order: Order, delivery: DeliveryInfo) {<br>        pushNotificationClient.send(<br>            order.customerId,<br>            &quot;Delivery Update&quot;,<br>            &quot;Your order will be delivered in ${delivery.estimatedMinutes} minutes&quot;<br>        )<br>    }<br>}<br><br>// Dependency Injection with Hilt<br>@Module<br>@InstallIn(SingletonComponent::class)<br>class AppModule {<br>    @Provides<br>    fun provideOrderRepository(): OrderRepository = DatabaseOrderRepository()<br>    <br>    @Provides <br>    fun provideNotificationService(): NotificationService = PushNotificationService()<br>    <br>    @Provides<br>    fun providePaymentProcessor(): PaymentProcessor = StripePaymentProcessor()<br>}<br><br>@HiltViewModel<br>class OrderViewModel @Inject constructor(<br>    private val orderService: OrderService<br>) : ViewModel() {<br>    // ViewModel uses OrderService abstraction<br>}</pre><h3>Why DIP Matters in Food Delivery</h3><ul><li>Easy to switch from database to cloud storage</li><li>Can change notification service (Email → Push) without affecting order logic</li><li>Testing becomes easier with mock implementations</li><li>Different restaurants can use different payment processors</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c9dcdc1949f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Deep Drive: The View System vs JetPack Compose]]></title>
            <link>https://medium.com/@nagajothyklearn/android-deep-drive-the-view-system-vs-jetpack-compose-32225ef81a42?source=rss-428d00a2eee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/32225ef81a42</guid>
            <dc:creator><![CDATA[Nagajothy - Mobile Application Developer]]></dc:creator>
            <pubDate>Tue, 21 Oct 2025 13:02:29 GMT</pubDate>
            <atom:updated>2025-10-21T13:02:29.961Z</atom:updated>
            <content:encoded><![CDATA[<p>Ever wondered how your Android app actually draws its buttons, text, and layouts on the screen? Let’s break down the two main characters in this story: the classic View System and the modern Jetpack Compose.</p><p>1. What Defines Them?</p><p>The Traditional View System(XML):<br>You design your UI in xml layout file. The Android Framework inflates these xml files and turns them into View and ViewGroup Objects like(TextView,Button,LinearLayout) that you can manipulate in your kotlin/java code.</p><p>It’s declarative but seperate. The what(XML) is seperate from the how(kotlin/java logic).</p><p>- JetPack Compose:<br>The modern Toolkit, you define your UI entirely in kotlin code using composable functions. There is no XML. you describe what your UI should like based on the current application state.<br>It’s Declarative and Unified. The what and the how live together in your kotlin code.</p><p>2. How Do They communicate?<br>View System: It’s a conversation between two different languages.<br> 1. Find the View- In your kotlin/java code, you use findViewById(R.id.mybutton) to get a reference to a UI element defined in XML. <br> 2. Set Listeners- you then set Listeners like setOnClickListener on that reference to react to user input.<br> 3. Update the View- To change the ui, you call methods on the VIEW object(textview.text=”New Text”)<br>JetPackCompose: It’s a Single, reactive flow.<br> 1. State is king: Your UI is the function of your state. you hold the data(state) in varaibles like MutableStateOf<br> 2. Recomposition: When the state changes, Compose automatically re-runs(recomposes) the relevant composable functions with the new data.<br> 3. No Manual Updates: You never manually update a UI element. you just change the state, and UI draws itself.</p><p>3. How Do They Work?<br>View System: It’s Object-Oriented and hierarchical. The screen is a tree of view and ViewGroup objects. The system traverses this tree to measure and layout each view, which can be a complex and sometimes slow process, especially with deep hierarchies.<br>JetPackCompose: It uses a more efficient approach. Composable functions are free of identity, they just describe the UI for a given state. During recomposition, Compose intelligently figures out what parts of the UI tree have changed and only updates those pieces, skipping the rest. This is generally fast and more predictable.</p><p>4. Who Started This?<br>The View System has been there since Android 1.0 (2008). It’s the foundation the entire platform was built on.</p><p>Jetpack Compose was announced by Google in 2019 at I/O. It reached its stable 1.0 release in July 2021, marking it as the modern, recommended way to build native Android UIs.<br>Let’s Get Interactive! Code Showdown<br>Let’s build a simple counter app that increments a number when you click a button.</p><p>Example 1: The Traditional View System (XML + Kotlin)<br>Step 1: The Layout (XML — activity_main.xml)<br>This defines the structure.<br>`&lt;LinearLayout<br> xmlns:android=”<a href="http://schemas.android.com/apk/res/android">http://schemas.android.com/apk/res/android</a>&quot;<br> android:layout_width=”match_parent”<br> android:layout_height=”match_parent”<br> android:orientation=”vertical”<br> android:gravity=”center”&gt;</p><p>&lt;TextView<br> android:id=”@+id/countText”<br> android:layout_width=”wrap_content”<br> android:layout_height=”wrap_content”<br> android:text=”0&quot;<br> android:textSize=”30sp” /&gt;</p><p>&lt;Button<br> android:id=”@+id/incrementButton”<br> android:layout_width=”wrap_content”<br> android:layout_height=”wrap_content”<br> android:text=”Click Me!” /&gt;</p><p>&lt;/LinearLayout&gt;`<br>Step 2: The Logic (Kotlin — MainActivity.kt)<br>This finds the views and controls the behavior.<br>class MainActivity : AppCompatActivity() {</p><p>private var count = 0</p><p>override fun onCreate(savedInstanceState: Bundle?) {<br> super.onCreate(savedInstanceState)<br> setContentView(R.layout.activity_main) // Inflate the XML</p><p>// 1. FIND the views<br> val countText: TextView = findViewById(R.id.countText)<br> val incrementButton: Button = findViewById(R.id.incrementButton)</p><p>// 2. SET the listener<br> incrementButton.setOnClickListener {<br> // 3. UPDATE the state and the view<br> count++<br> countText.text = count.toString() // Manual UI update!<br> }<br> }<br>}<br>See the manual findViewById and the direct text property update? That’s the classic pattern.<br>Example 2: Jetpack Compose (Only Kotlin)<br>Just One File: The Composable (Kotlin)<br>The structure and logic are unified.<br>class MainActivity : ComponentActivity() {<br> override fun onCreate(savedInstanceState: Bundle?) {<br> super.onCreate(savedInstanceState)<br> setContent { // This is where Compose starts<br> CounterApp()<br> }<br> }<br>}</p><p><a href="http://twitter.com/Composable">@Composable</a><br>fun CounterApp() {<br> // 1. STATE is the source of truth.<br> var count by remember { mutableStateOf(0) }</p><p>// 2. The UI is described as a function of that state.<br> Column(<br> modifier = Modifier.fillMaxSize(),<br> verticalArrangement = Arrangement.Center,<br> horizontalAlignment = Alignment.CenterHorizontally<br> ) {<br> Text(<br> text = count.toString(),<br> fontSize = 30.sp<br> )<br> Button(<br> onClick = {<br> // 3. Just update the state!<br> count++ // The UI auto-magically updates!<br> }<br> ) {<br> Text(“Click Me!”)<br> }<br> }<br>}<br>Notice the magic? There’s no findViewById, no manual UI update. Change the count state, and the Text recomposes itself. The UI is a function of the state.<br>Their Scope &amp; The Bottom Line <br>View System: It’s mature, stable, and everywhere. Billions of apps use it. You need to know it to maintain existing codebases. It’s not going away anytime soon.</p><p>Jetpack Compose: It’s the future. It’s faster to write, more intuitive, and less error-prone. For all new projects, this is the highly recommended path.</p><p>So, which one should you learn?<br>Start with Compose. It’s more fun and represents modern UI development paradigms. But understand the basics of the View System because you’ll inevitably encounter it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=32225ef81a42" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Flutter Interview Questions And Answers]]></title>
            <link>https://medium.com/@nagajothyklearn/flutter-interview-questions-and-answers-e4d9101f22c5?source=rss-428d00a2eee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/e4d9101f22c5</guid>
            <dc:creator><![CDATA[Nagajothy - Mobile Application Developer]]></dc:creator>
            <pubDate>Sat, 29 Mar 2025 09:17:47 GMT</pubDate>
            <atom:updated>2025-03-29T09:17:47.877Z</atom:updated>
            <content:encoded><![CDATA[<ol><li>What is Flutter?</li></ol><p>Flutter is an open source UI Framework developed by Google and is now maintained by ECMA Standards for building natively compiled applications across multiple platforms such as Mobile(Android &amp; IOS), Web, Desktop and Embedded Devices from a Single Code Base.</p><p>2. What are the key components of Flutter?</p><p>To truly understand how Flutter works, let’s break it down into its core components:</p><p><strong>a. </strong>Flutter uses the Dart Programming Language:</p><p>Flutter is built on Dart, which is a modern programming language developed by Google. But Why Dart?</p><ul><li><strong>AOT( Ahead Of Time Compilation ) </strong>— Dart compiles the code before the app runs. Unlike JavaScript, which interprets the code at runtime. This leads to faster startup times and smooth performance.</li><li><strong>JIT ( Just-In-Time Compilation) — </strong>During development, dart enables HotReload feature — the updated code is injected into the running Dart Virtual Machine and the changes are reflected immediately in the app. This means that the developers can instantly see UI updates without restarting the app.</li><li>so, dart allows flutter to be in both fast production and flexbile development.</li></ul><p>b. Reactive Framework: How Flutter handle UI Updates:</p><p>Flutter follows a reactive programming model, meaning that the ui update automatically when the data changes.</p><p>👉 Imagine a Shopping Cart App:</p><p>If you add an item, the cart icon should update to show the new item count.</p><p>In Flutter, you don’t update the ui manually.</p><p>Instead, Flutter rebuilds only the part of the UI that changed, making it super efficient.</p><p>c. Everything is a Widget — The Widget Tree</p><p>Flutter uses a widget-based architecture , meaning everything you can see on the screen is a widget.</p><p>👉 Consider a <strong>button in an app</strong>:</p><p>The button is widget.</p><p>The text is inside the button is also a widget.</p><p>The background color of the button is also a another widget.</p><p>Widgets are organized as widget-tree similar to a family tree.</p><p>App <br>│ <br>├── Scaffold (Screen layout) <br>│ ├── AppBar (Title bar) <br>│ ├── Column (Vertical layout) <br>│ │ ├── Text (“Welcome to Flutter”) <br>│ │ ├── Button (“Click Me”) <br>│</p><p>d. Hot Reload- Secret to Fast Development</p><p>Flutter’s Hot Reload feature allows developers to see changes in real time without restarting the app.</p><p>👉 Traditional app development:</p><p>🔹Change the code -&gt; Stop the app -&gt; Recompile -&gt; Restart -&gt; Test</p><p>This is slow and frustrating.</p><p>👉 Flutter with Hot Reload:</p><p>🔹Change the code → Instantly see updates in the app.</p><p>Example:</p><p>If you change a button color from blue to red, you can see the color update instantly in the running app, without losing your current app state.</p><p>e. Skia Rendering Engine — How Flutter looks the same everywhere</p><p>Flutter doesn’t use native ui componenets unlike react native. Instead, it draws everything from scratch using Skia, a powerful 2D graphics engine.</p><p>🔹Consistent UI across platforms: The app looks same on Android and ios.</p><p>🔹Smooth Animations: Skia redraws the ui 60 to 120 times per second, making animations fluid.</p><p>🔹No reliance on OS Updates: Flutter apps don’t break when the IOS or Android updates their UI.</p><p>f. Native Performance without a bridge:</p><p>Many cross platform uses bridge to communicate with native components.This bridge causes performance delays.</p><p>Flutter compiles directly into Arm Machine Code using Dart’s AOT compilation.</p><p>No need for a javascript bridge, resulting in faster execution and lower latency.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4d9101f22c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Flutter Architecture Layer Overview]]></title>
            <link>https://medium.com/@nagajothyklearn/flutter-architecture-layer-overview-6add8ea20df3?source=rss-428d00a2eee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/6add8ea20df3</guid>
            <dc:creator><![CDATA[Nagajothy - Mobile Application Developer]]></dc:creator>
            <pubDate>Mon, 04 Nov 2024 13:53:06 GMT</pubDate>
            <atom:updated>2024-11-04T13:53:06.804Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ScJqF-ZBOGtvCcAm.png" /></figure><p>The image shows the architectural layers of Flutter, including the <strong>Framework</strong>, <strong>Engine</strong>, and <strong>Embedder</strong> layers, with various components listed under each. Here’s a detailed explanation of each layer and its components:</p><p>Flutter’s architecture can be summarized into three main layers:</p><ol><li><strong>Framework Layer</strong> (written in Dart)</li><li><strong>Engine Layer</strong> (written in C++)</li><li><strong>Embedder Layer</strong> (platform-specific)</li></ol><h3>1. Framework Layer (Dart)</h3><p>The Framework layer is the topmost layer, written in Dart, and is where developers interact the most. It provides a rich set of libraries and tools to build UI, handle gestures, and manage state.</p><ul><li><strong>Material</strong>: Implements the Material Design guidelines, providing ready-made widgets that adhere to Android’s design principles.</li><li><strong>Cupertino</strong>: Provides Cupertino-styled widgets that follow iOS design patterns, making it easy to create iOS-styled apps.</li><li><strong>Widgets</strong>: The core building blocks of the Flutter UI. Widgets are immutable descriptions of part of the UI.</li><li><strong>Rendering</strong>: Handles layout and painting of widgets on the screen.</li><li><strong>Animation</strong>: Contains tools and widgets for adding animations, such as transitions and animations between states.</li><li><strong>Painting</strong>: Manages lower-level painting, including shapes, colors, and images.</li><li><strong>Gestures</strong>: Detects touch interactions, such as taps, drags, and gestures, enabling user input handling.</li><li><strong>Foundation</strong>: Provides low-level building blocks, such as APIs for basic types and utilities needed to build the higher layers of the framework.</li></ul><h3>2. Engine Layer (C/C++)</h3><p>The Engine layer is built using C++ and provides the core rendering, accessibility, text layout, and other platform-independent functionalities.</p><ul><li><strong>Service Protocol</strong>: Enables debugging and developer tooling by allowing the Flutter framework to communicate with IDEs.</li><li><strong>Dart Isolate Setup</strong>: Sets up isolates, or independent Dart execution contexts, to enable concurrency and parallel processing.</li><li><strong>Dart Runtime Management</strong>: Manages the execution of Dart code, handling the Dart VM and garbage collection.</li><li><strong>Composition</strong>: Responsible for compositing layers and scenes, combining multiple visual elements into one.</li><li><strong>Rendering</strong>: Handles the actual drawing of the widgets on the screen.</li><li><strong>Frame Scheduling</strong>: Manages the rendering pipeline, ensuring smooth frame rates and responsive animations.</li><li><strong>Platform Channels</strong>: Provides a mechanism for communicating between Dart and native platform code (e.g., calling Android/iOS code from Dart).</li><li><strong>System Events</strong>: Handles various system-level events, such as app lifecycle changes and screen rotation.</li><li><strong>Asset Resolution</strong>: Manages assets, such as images, and adjusts them based on the device’s resolution and pixel density.</li><li><strong>Frame Pipelining</strong>: Optimizes the pipeline to ensure the next frame is rendered while the current one is displayed.</li><li><strong>Text Layout</strong>: Manages text layout and font rendering, supporting complex scripts and multi-language layouts.</li></ul><h3>3. Embedder Layer (Platform-Specific)</h3><p>The Embedder layer is platform-specific and enables Flutter to work on various operating systems. This layer provides platform-specific implementations to interact with underlying system services.</p><ul><li><strong>Render Surface Setup</strong>: Manages the creation and setup of surfaces for rendering content on different platforms (e.g., OpenGL on Android, Metal on iOS).</li><li><strong>Native Plugins</strong>: Supports platform-specific plugins to interact with device features like cameras, sensors, and other native capabilities.</li><li><strong>App Packaging</strong>: Handles building and packaging the app for deployment on iOS, Android, Windows, Linux, macOS, and other platforms.</li><li><strong>Thread Setup</strong>: Manages thread allocation and prioritization to maintain smooth UI performance and efficient processing.</li><li><strong>Event Loop Interop</strong>: Interacts with the platform’s event loop, allowing Flutter to receive system events and schedule frame rendering.</li></ul><h3>Real-Time Example</h3><p>Imagine you’re building a <strong>ride-sharing app</strong>. Here’s how each layer would play a role:</p><ol><li><strong>Framework</strong>:</li></ol><ul><li>You’d use <strong>Material</strong> or <strong>Cupertino</strong> for designing UI components, like buttons and cards.</li><li>Use <strong>Widgets</strong> for displaying ride details, user profiles, and maps.</li><li>Use <strong>Animation</strong> for showing smooth transitions when the ride status updates.</li><li><strong>Gestures</strong> would handle user interactions, such as swiping to cancel a ride or tapping to confirm pickup.</li></ul><p><strong>2. Engine</strong>:</p><ul><li>The <strong>Rendering</strong> system would handle drawing and updating the UI.</li><li><strong>Platform Channels</strong> would enable communication with native code for maps and GPS location.</li><li><strong>Text Layout</strong> would render any dynamic text, such as ride costs and driver details.</li></ul><p><strong>3. Embedder</strong>:</p><ul><li><strong>Native Plugins</strong> would be used to access device features, such as GPS for location tracking.</li><li><strong>Event Loop Interop</strong> would manage event scheduling to keep the app responsive and handle background processes for location updates.</li></ul><p>This architecture allows Flutter to build cross-platform apps with near-native performance by balancing high-level development ease with lower-level system integration.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6add8ea20df3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Understanding the Background Processes When Creating a New Flutter Project in Android Studio”]]></title>
            <link>https://medium.com/@nagajothyklearn/understanding-the-background-processes-when-creating-a-new-flutter-project-in-android-studio-3a8a9c06958d?source=rss-428d00a2eee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a8a9c06958d</guid>
            <dc:creator><![CDATA[Nagajothy - Mobile Application Developer]]></dc:creator>
            <pubDate>Thu, 24 Oct 2024 08:06:53 GMT</pubDate>
            <atom:updated>2024-10-24T08:06:53.235Z</atom:updated>
            <content:encoded><![CDATA[<p>When you create a new Flutter project in <strong>Android Studio</strong>, several background tasks run automatically to set up the project and make it ready for development. Here’s a breakdown of what happens:</p><h3>1. Project Structure Initialization</h3><p>When you create a new Flutter project, Android Studio generates the default Flutter project structure. This includes:</p><ul><li><strong>Dart code files</strong>: Main entry point (main.dart) and other essential directories like lib, test, etc.</li><li><strong>Android and iOS native code</strong>: It generates the required Android and iOS native directories (android/, ios/), including Gradle files for Android and Xcode project files for iOS.</li><li><strong>Configuration files</strong>: Such as pubspec.yaml (for dependencies), .gitignore, README.md, and more.</li></ul><h3>2. Analyzing</h3><ul><li><strong>Dart Analyzer</strong>: The Dart analyzer is responsible for analyzing the Dart code in your Flutter project. It checks the code for errors, warnings, unused imports, and provides suggestions. The analyzer runs in the background as you write code and provides real-time feedback in the IDE.</li><li><strong>Flutter-specific Analysis</strong>: Flutter-specific code analysis, such as checking for improper widget usage, layout issues, or potential performance problems (e.g., expensive rebuilds), also occurs during this step.</li></ul><h3>3. Indexing</h3><ul><li><strong>Indexing</strong> is the process of scanning all files in your project, including Dart files, configuration files (pubspec.yaml), and any external dependencies you add to the project.</li><li>This step builds an internal index of the project’s symbols (variables, methods, classes, etc.), which Android Studio uses to:</li><li>Provide <strong>code autocompletion</strong> (intellisense).</li><li>Enable <strong>fast navigation</strong> between different parts of your codebase.</li><li>Improve <strong>search results</strong> when looking for specific symbols or functions.</li><li>Detect file changes quickly.</li></ul><p><strong>Why is indexing important?</strong><br>It allows Android Studio to keep track of the entire codebase and dependencies, so you get features like refactoring, code suggestions, and instant error detection while coding.</p><h3>4. Dependency Management</h3><ul><li><strong>Pubspec Resolution</strong>: Flutter uses the pubspec.yaml file to manage dependencies. When you create a new project, Android Studio automatically runs flutter pub get, which:</li><li>Downloads and installs the dependencies (if any are listed) from the Dart/Flutter package repositories.</li><li>Creates a .packages file that maps all the libraries being used in the project.</li><li><strong>Lock File Creation</strong>: The pubspec.lock file is created, which locks the versions of the dependencies you are using in your project.</li></ul><h3>5. Gradle Sync (for Android)</h3><ul><li>For the Android part of your Flutter project, Android Studio runs a <strong>Gradle sync</strong>. This process:</li><li>Syncs the project with Gradle (the build automation tool used for Android projects).</li><li>Downloads any Android SDK components or libraries required by the project.</li><li>Ensures that the Gradle build system is properly set up and all necessary plugins are available.</li><li>This is essential for tasks like building, testing, and deploying the Android portion of your Flutter app.</li></ul><h3>6. Build Configuration Generation</h3><ul><li><strong>Android Build Config</strong>: Android Studio generates the necessary Gradle build configuration files (build.gradle, settings.gradle) in the android/ folder. These files are crucial for building and packaging your app.</li><li><strong>iOS Build Config</strong>: Similarly, the ios/ folder contains Xcode project files and configuration settings for iOS development.</li></ul><h3>7. Initial SDK and Platform Detection</h3><ul><li><strong>Flutter SDK</strong>: Android Studio verifies the installed Flutter SDK path and ensures that it’s correctly linked to the project.</li><li><strong>Android SDK</strong>: It also checks the Android SDK installation (for Android projects) and links it to the Flutter project for native Android functionality.</li><li><strong>Device Detection</strong>: The IDE detects the available devices (emulators or physical devices) connected to the development environment, enabling the “Run” option for testing.</li></ul><h3>8. Generating Launch Configurations</h3><ul><li>Android Studio generates default run/debug configurations for the project. This includes:</li><li>Flutter Run/Debug configurations for running the app on different devices (Android, iOS, etc.).</li><li>Flutter Test configurations if the project has unit or widget tests.</li></ul><h3>9. Dart DevTools Integration</h3><ul><li>Dart DevTools is automatically integrated into the project. These are debugging and performance tools for Flutter and Dart apps. Android Studio ensures that DevTools is available for profiling, inspecting UI, and performance debugging when you run your Flutter app.</li></ul><h3>10. Hot Reload/Restart Setup</h3><p>Android Studio configures the Flutter development environment to allow for <strong>hot reload</strong> and <strong>hot restart</strong>, essential for Flutter development. These features are crucial for fast development cycles as they let you instantly see the effect of code changes without restarting the whole app.</p><h3>11. Linting and Formatting Setup</h3><p>Linting and formatting rules are applied to ensure that the project follows best practices and coding guidelines. The <strong>Dart formatter</strong> is automatically configured, and linting warnings or errors are highlighted in the IDE.</p><h3>Summary of Key Processes:</h3><ul><li><strong>Analyzing</strong>: Checks for errors and warnings in Dart code, providing feedback in real-time.</li><li><strong>Indexing</strong>: Scans and tracks all files for quick access, navigation, and code completion.</li><li><strong>Dependency Management</strong>: Manages and installs the project’s dependencies through pubspec.yaml.</li><li><strong>Gradle Sync</strong>: Syncs and configures the Android-specific Gradle build system.</li><li><strong>Initial Setup</strong>: Configures the Flutter SDK, devices, and build configurations.</li><li><strong>Dart DevTools</strong>: Integrates powerful tools for debugging and performance profiling.</li></ul><p>All these tasks prepare your project for a smooth Flutter development experience with Android Studio, offering powerful features such as code suggestions, error detection, and real-time performance tools.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a8a9c06958d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin Tutorial- Basics]]></title>
            <link>https://medium.com/@nagajothyklearn/kotlin-tutorial-basics-6c287269f86c?source=rss-428d00a2eee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c287269f86c</guid>
            <dc:creator><![CDATA[Nagajothy - Mobile Application Developer]]></dc:creator>
            <pubDate>Tue, 21 May 2024 13:47:01 GMT</pubDate>
            <atom:updated>2024-05-21T13:47:01.755Z</atom:updated>
            <content:encoded><![CDATA[<p>Kotlin Tutorial- Basics</p><p>Referred Link: <a href="https://developer.android.com/courses/android-basics-compose/course">https://developer.android.com/courses/android-basics-compose/course</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c287269f86c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[IOT Ecosystem]]></title>
            <link>https://medium.com/@nagajothyklearn/iot-ecosystem-47f7a950390e?source=rss-428d00a2eee6------2</link>
            <guid isPermaLink="false">https://medium.com/p/47f7a950390e</guid>
            <dc:creator><![CDATA[Nagajothy - Mobile Application Developer]]></dc:creator>
            <pubDate>Tue, 14 May 2024 12:17:59 GMT</pubDate>
            <atom:updated>2024-05-14T13:03:15.327Z</atom:updated>
            <content:encoded><![CDATA[<p>Overview</p><p>An IOT Ecosystem is a system that encompasses necessary elements such as to collect, process and analyze data generated by IOT devices.</p><p>Components of IOT Ecosystem</p><p>IOT Ecosystem consists of four main key components:</p><ol><li>Device.</li><li>Connectivity.</li><li>Data Processing.</li><li>Application.</li></ol><p>Device:</p><p>Device is the physical object that is connected to the network. It can be simple as RFID tag, WIFI, Bluetooth enabled devices or complex as a drone with sensors and cameras that collects data about its surroundings and send back to the controller for analysis by machine learning algorithms.</p><p>Connectivity:</p><p>Connectivity can be wired or wireless networks that can be used by devices in order to connect with each other over long distances or short distances respectively. These networks connects devices at their endpoints with a centralized hub which then distributes across large distances.</p><p>Data Processing:</p><p>Data Processing involves transforming the raw data into useful insights through machine learning technique.</p><p>Applications:</p><p>Applications can be defined as a software programs used by humans to interact with their physical surroundings through various interfaces such as web browsers or mobile apps.</p><p>An IOT Ecosystem is the result of an IOT device connecting to a network, sending raw data to an IOT platform , which then processes it and sends to an application for analysis or visualization.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=47f7a950390e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>