
iOS App Developer having 7.8 years of professional experience and also worked on SwiftUI project for more than 1 year. iOS || Swift || SwiftUI || Combine || Swift Concurrency || MVVM || HTML || CSS || JavaScript || SQLite.
Technical Specialist
Zensar TechnologiesPrincipal Software Engineer
MouriTechiOS Software Engineer III
ConvergysJr iOS Software Engineer
V-Soft Consulting Corporation Pvt LtdiOS Software Engineer
Collabnotes LLP
SPM
Figma

GitHub

iOS SDK

Git
Jira

Agile

SQLite

Core Data

Swift

SwiftUI

Objective C

UIKit

JSON

Combine

Concurrency

Multithreading

Memory Management

ARC

OOPs

SOLID Principles

MVC

MVVM

Design Patterns

UI/UX Design

Unit Testing

Dependency Injection
Myself, Shiram. Yes, I have started my career with Visa. There I have worked on a few ecommerce applications, like one education application. And then I started with Collab Notes. That is also a health care product. There I worked on health-related records to this station. After that, I got an opportunity with Concentrix, where I worked on a social media kind of application. So this is the organization where I worked on a more tech side, with the fiscal aspect of an automotive application. Then, we posted a point of sale, which is also a kind of weak ecommerce application. We can load a register onto onboard commerce platforms, including retail ecommerce into flights. The crew member will then do the point of sales. That is my career background. Coming to my education background, I completed a B Tech in Electrical Engineering at the Inter Engineering College. That is my highest level of education. That is briefly for myself.
Can you outline the strategy for caching data from this API case in an iOS version using Core Data? Yeah. By using Core Data, we can create a database by initializing the Core Data stack. So it will use a managed object context object like a persistent store coordinator and a managed object model. The managed object model acts as a database schema. So once we prepare our database schema between how the entities, how the columns, and how the entities are connected by using relationships. So after that, we can load whatever data is coming from the REST APIs into Core Data. If any further API calls are required, instead of doing a REST API network call, we can check if the data is available in Core Data. If it is, we will not make the API call, and then we'll retrieve the data from Core Data and display it in the app. So like that, we can cache it.
Describe the approach to implement lazy loading of emails in my capabilities. Lazy loading is the technique. Instead of loading all the emails, 100 of them at the same time, whenever that cell comes into the visible area, that time only we can load the images lazily. And also, we can use a caching mechanism, by using NS caching. So if the image is already available, we can load from the cache lazily. If the image is not available, we will get it from the server and then dump it into the NS cache. So like this, we can load emails slowly based on the visibility of the cell.
What strategies would you apply to manage the steady effect efficiently in a complex area? What strategies would you apply to manage state efficiently in that area? Yeah, we can move at state at state, property wrapper and binding property wrapper. If that variable is changing inside the scope of that particular view, that is the best way. If the variable is outside our view scope, then we can reference it inside our SIFT UI view by using an at state object or at properties, I mean property graph. So this way, we can easily maintain the complex state.
What is the best practice for managing memory when dealing with large collections of data models in iOS? The best way is to dump and save them into a database, and then we can read from the database batch by batch. At the time, it's not required to load all the data models into the table view or collection view. So, we can load batch by batch, using a page technique, even from the server or from the database also.
We can unwrap options using a uflet, gauntlet, or anil coalescing operators. Based on the scenarios, we can go for either of three options.
Look at this code used to process data with a for loop, what could potentially go wrong here, and how might this affect the app's performance or stability. Okay? Persistent container view context, entity, and this entry description for entity and user in context, this small object entity. Entity and this setting context. New user set to value "John" for key "name" to try catch to find look at this code. The user would assist data. You can put it a lot. Could you see and go down here and then how might you be able to handle errors or exceptions? So here, key I mean, keys, we are doing manually. Your keys, we are doing manually, instead of hardcoding, we can use properties. And also, entity can be directly created from the user entity. It will use a user context. If we give context, that will give the entity. So based on that, we can add directly, like when you use a dot name, equal to that, we can do. This way, we can potentially reduce the complexity. Yeah.
Analyze this block of code, can you explain if follows a solid principle with a single responsibility? I have not suggested a way to report it. Create user, delete user, update user, log user in. Log user in, log user, or fetch user. So single responsive filtering particular entity has only one actor. Actor in the sense, like, the change coming from, employee I mean, management that related to one actor. One actor are one responsibility. So in that in that in that aspect so create user, delete user, update user, like, fetch user related to one kind of, one kind of act up, like, a responsibility. So we can bring all these 4 methods under user manager. then user credential manager, we can use, like, user login, user logout as the separate classes. I mean, in the separate class with the class name as user credential manager. So this way, if this will bring this will make, like, user manager is one actor. It has some responsibility. And also, user credential manager is another actor. It has some other responsibility. So this way, we can make that responsibility split into the between the two classes. Makes it will follow SRPs in this way.
Difficult. Very hard. Can you detail how you would use GCD for performing concurrent app licensing as a well-managing field safety with Core Data? Yeah. We can use context to perform and wait. It will do all the operations. It will add to one background queue, where it will perform serial manner. And also, directly, we can use context dot perform. It will do concurrent operations. So these are thread-thread shape. So, Core Data by using these two, we can make Core Data like a dataset. For that, we can use new background context instead of new context. So it will be more useful and, more concrete approach.
How would you approach unit testing in your product that utilize both the Wiki and Safety APIs? How would you approach in a custom union file that utilize both the Wiki and the etcetera enterprise? We can we can use, like, a c test class based on the whatever interface, and then we'll create, like, a view model. And then that view model, we can isolate and we can test any interface. It is fine.
When setting up a CSV that cannot exist in iOS or private, it would be characterized by the fact that we can create one now. Suppose we have the code in the Bitbucket repository. If any code commit or push happens, any pull request will happen from source to destination. That time, we can write one webhook. That webhook will trigger when something new is there in the Bitbucket server. Then in the Jenkins server, that will check out the code from Bitbucket to Jenkins server. In the Jenkins server, we will have the pipeline. It has clean and checkout in one stage. Then we have version information setup. Next, we have a build step where we build the app, then we will do unit tests on top of that. After that, we will create an IP bill. The next stage is to deploy that IP to a particular environment, either TestFlight or Optum, so we can start building a better plan.