Ashish Kumar

Knowledge Sharing: Day 7 Singletons in Swift A class Singleton provides a single, globally accessible instance that can be accessed via referance whereas a struct Singleton creates copies when accessed. Struct singlton is by definition is thread safe but a class singleton suffers from risk of concurrent modifications. #Swift #SwiftUI #UIKit #iOS #iOSDevelopment #Singletons #AppDevelopment #Programming #MobileDevelopment

15

Hi #androiddev 👋 I have been looking into open-source projects on Android and have seen these two popular multi-module Architectures. 1. Core Module and Feature base Architecture (#Type 1) 2. Feature Module-based Architecture (#Type2) 🏛️ #Type1 has a core module that contains all the core dependencies of the feature module, such as data models, analytics, design system, database, and API Services. These will be added to the feature module to perform the specific task. 🏛️ #Type2 Architecture: This core module is part of the feature module as a package. For example, if there is a cart feature, there will be a cart module that contains all the core codes like analytics, API Clients, data models, etc. in the feature module itself. Thus, there is a centered core module that has all the APIs added for each feature. Both of them have their advantages and disadvantages. Let me know which type of Multi-Module Architecture you used in your projects. #Type1 Good Example is https://lnkd.in/gDJ6AQfM #Type2 :- https://lnkd.in/gTQdjisX 📝 I'll share more insights by looking into these open-source projects. #android #architecutre #kotlin #mulitmodule #compose

183

2 Comments

Kotlin's Beauty!!! We all have used as whether an element in list, map or set using if (item in map), but a simple yet very beautiful twist to it is if (item !in map) this means if the item is not in map then do something. These simple things make kotlin stand ahead.. #kotlin #android

21

Just going through the NamastheyJS series from Akshay Saini 🚀! Found out that 'Hoisting' is not an explicit term defined in ECMAScript! It's more of considered as a default behaviour of JS rather than some special feature. More on this: https://lnkd.in/gbW7aMFJ #JS #frontend

14

2 Comments

Reading a JSON File in Swift ✅ From the main bundle Useful for an app's static data and SwiftUI previews ✅ From the documents directory Useful to easily store user-generated data without complex solutions like SwiftData #swift #swiftui #iosappdevelopment

71

2 Comments

15 System Design Articles, tutorials and case studies to get better at Software architecture and System Design How Razorpay Scaled to Handle Flash Sales at 1500 Requests per Second https://lnkd.in/ge6Zbaza How Stripe Prevents Double Payment Using Idempotent API https://lnkd.in/gSBkwUaE How McDonald’s Food Delivery Platform Handles 20,000 Orders per Second https://lnkd.in/gA4aPsJf What is Database Sharding? https://lnkd.in/gPTn2hdY Difference between JWT, OAuth, and SAML https://lnkd.in/gAAXFaxt Database Indexes: A detailed guide https://lnkd.in/g-7jV_jK The Complete Guide of Database Sharding for System Design Interview https://lnkd.in/g24cfdcj Basic OOP Concepts Explained with Code https://lnkd.in/gvEm3925 Latency is a silent killer. https://lnkd.in/gzXwuCJJ Database Intermediate Series: Change Data Capture(I) https://lnkd.in/gQgQrZm6 How LinkedIn Authorizes 10 Million API Calls Per Second https://lnkd.in/gdCGfjY4 What is Clean Architecture? https://lnkd.in/grHEm6yc How CQRS Pattern Works in Microservices? https://lnkd.in/grdeaxCx How does SSO Single Sign On Authentication Works? https://lnkd.in/gNPRNYcb What is Rate Limiter? How does it work? https://lnkd.in/gasgYAxc 10 System Design Topics You Must Prepare for Tech Interviews? https://lnkd.in/gJckDzKW How to Design WhatsApp or Facebook Messenger? Messaging App System Design in 5 Minutes? https://lnkd.in/gw45PzH5 How Stripe Prevents Double Payment Using Idempotent API https://lnkd.in/gSBkwUaE Top 11 Resources to Crack the System Design Interview? https://lnkd.in/gFbbkDgq Difference between Kafka, RabbitMQ, and ActiveMQ? https://lnkd.in/g-CamE7P Free System Design Courses and YouTube channels for Tech Interviews https://lnkd.in/gbY4qDTm How to Prepare for System Design Interviews? https://lnkd.in/gtRxer6m

4

Question for Android Developers: Can a use case have multiple methods? I usually see use cases with a single invocation method, like the below one. I know some people are not fans of the use case pattern, but please bear with me and hold off on arguments for a while 😀 . #android #androiddevelopers

99

73 Comments

Adding timeout in Network Call using Kotlin Coroutines - "withTimeout" Keep Learning, Keep Sharing, and Keep Growing. Follow Outcome School for knowledge-packed content. #OutcomeSchool #SoftwareEngineering #Tech #AndroidDev #Android #Kotlin

74

1 Comment

One of the greatest sources of mistakes in Kotlin is incorrectly implemented synchronization. This leads to data loss or, even worse, object inconsistency and exceptions. class OrderService { private val processedOrders = mutableListOf<Order>() fun processOrder(order: Order) { // ... processedOrders.add(order) // MISTAKE! // Order might not be added, or an exception might be thrown } // ... } We deal with those problems whenever multiple threads access the same data in parallel, and some of them make modifications. Let's learn how to recognize those problems, and how to solve them. Let's start with a simple example, where 10,000 threads (or coroutines running on more than one thread) try to increment a number. If there were no conflicts, the result should be 10,000, but the actual result will be smaller, like 7828. suspend fun main() { var num = 0 coroutineScope { for (i in 1..10_000) { launch { // uses Dispatchers.Default delay(10) num++ } } } print(num) // The result very unlikely to be 10000 } Why is that? i++ looks like one operation, but under the hood are three operations: getting the value of i, incrementing the result, and setting it to i. Those are atomic operations, but there are three of them. Each of them can be executed in parallel on to threads, or OS can decide to stop thread execution between them. So two threads can at the same time take the same value, then each increments it and assigns the result, and as a result, one update is lost. Or after one thread gets value and incremenets it, a OS can stop it, and execute other increments, once OS gets back, it sets old value incremented, and intermediete updates are lost. The same can be observed with collections. With read-only collections and var, read and assignment are atomic operations, but an update requires reading, updating (multiple operations), and assignment. The risk of collisions is big. It does not help to use a mutable collection, because methods of those collections are not atomic neither. They are faster, so the risk of collisions is smaller, but there is a risk that unfortunate collision can cause collection inconsistence. How can we deal with those problems? Popular solutions involve: - Using synchronized block - Using concurrent collections - Using atomic values - Using a dispatcher limited to a single thread - Using mutex Each of those solutions has its pros and cons, neither of them is a silver bullet and using the appropriate technique is essential to balance efficiency, convenience and safety. I will explain each of those techniques, together with their pros and cons, in the upcoming tweets. So stay it touch if you are interested. I teach that in my workshop, Kotlin Mastery, which is available for companies and will have an open edition in November. https://lnkd.in/duKBt-sV

55

1 Comment

Excited to share our comprehensive guide on Android App Development! From setting up Android Studio to implementing advanced features, this article covers it all. Perfect for both beginners and seasoned developers. #AndroidDev #AppDevelopment #Tech #MobileApps #Programming #SoftwareDevelopment #Java #Kotlin #AndroidStudio #TechBlog #DeveloperCommunity #TechAhead Read the full article here. https://lnkd.in/g9XMGWcU

12

Detailed Steps for CI/CD pipeline for react native https://lnkd.in/dxcewZGj #ci/cd #reactnative

16

How does Xcode magically convert print(“Hello, World!”) into an iOS App !!? 1. Writing the Code: Lets write print(“Hello, World!”) in a file say main.swift 2. Lexical Analysis: The compiler breaks down the above code into 5 tokens- ‘print’, ‘(‘, ‘“Hello, World!”’, ‘)’, ‘;’ 3. Syntax Analysis: Abstract Syntax Tree(AST) is created     FunctionCallExpression       ├── FunctionName: print       ├── Arguments:               └── StringLiteral: "Hello, World!"  4. Semantic Analysis: The compiler performs checks on AST to ensure print function exists and can accept a string argument in Swift Language.  5. Intermediate Representation(IR) Generation: The compiler translates the AST into a low level, platform-independent representation of the code:  %0 = load StringLiteral, "Hello, World!"  call @print(%0)   6. Optimised IR: The IR undergoes various optimisations like constant folding, dead code elimination and loop unrolling. Here the optimisation is to directly use the string literal in the call. call @print("Hello, World!") // Optimisation: directly use the string literal in the call 7. Code Generation: The optimised IR(platform-independent) is translated into assembly instructions that can be executed by the target processor. Object file main.o contains below machine code:     mov r0, # HelloWorldString // Move the address of the string into register r0     bl _print         // Branch to the 'print' function     .data     HelloWorldString:        .asciz "Hello, World!"  // Define the string in the data section 8. Symbol Resolution: The Linker finds the definition of ‘print’ function in the Swift Standard Library(‘libswiftCore.dylib’) 9. Address Binding: The ‘print’ function is assigned a specific address(say 0x1000) in the final executable file. 10. Library Linking: Swift Standard Library libswiftCore.dylib is referenced from executable file and not copied into it so that the library can be shared across multiple Swift programs and is loaded to memory at runtime. This keeps the size of executable file small. 11. Handling Dependencies: The linker builds a dependency graph ensuring all required libraries and frameworks are included. Here libswiftCore.dylib depends on libobjc.dylib so both are referenced from the final executable file. 12. Creating the Executable: The linker combines object file, libraries and frameworks into a single executable file(say-HelloWorld) in mach-o format. Above steps are executed when we run below command on Terminal:   swiftc main.swift -o HelloWorld 13. The iOS App(.app file) is packaged as a directory containing the executable file(HelloWorld), resources(like images and storyboards) and metadata(like Info.plist) #KeepCoding #KeepLearning #KeepGrowing

11

Common Challenges Of Developing A Flutter Finance Mobile App https://lnkd.in/gcHE8Rat #thesiliconreview #LatestNews #BreakingNews #CommonChallenges #developing #flutter #finances #MobileApps

3

Attention iOS developers! Have you experienced performance issues while loading large images? Did you know that loading a large image on the main thread can cause significant performance issues for your app? When the main thread is blocked, users experience delays in their interactions with your app. But don't worry, there's a solution! One way to avoid this issue is to use the prepareForDisplay method. By calling this method on a UIImage, the image will be decoded on a background thread, and then displayed once it's ready. Here's an example code snippet: import UIKit let image = UIImage(named: "image") image?.prepareforDisplay{ [weak self] image1 in DispatchQueue.main.async { self?.imageView.image = image1 } }

139

3 Comments

A big-time shoutout to our Flutter-ing Expert Mukund Jogi 😍 FlutterFlow Developer Group Ahmedabad invited him as an esteemed speaker on leveraging FlutterFlow for API integration and custom library creation! 🙌 He even highlighted how such powerful combinations can accelerate development and reduce code duplication, allowing you to build apps faster than ever! ⏫ #flutter #techevent #flutterdevelopers #FFDGAhmedabad #flutterflow #community

117