5 exercises — essential vocabulary for iOS, Android, and cross-platform mobile developers: app types, lifecycle, deep links, build distribution, and SDKs.
A mobile developer is explaining architecture choices to a new team member: "We chose React Native so we can share most of the codebase between iOS and Android, but it compiles to native components — it's not running in a WebView." Which category best describes React Native?
Mobile app development has four main approaches: Native (option A): written in platform-specific languages — Swift/Objective-C for iOS, Kotlin/Java for Android. Separate codebases, maximum performance and platform integration, highest development cost. Cross-platform with native rendering (option B — React Native, Xamarin MAUI): shared codebase (JS/TS or C#) that renders to native platform components. Good performance, lower cost than full native, minor platform-specific code still needed. Hybrid / WebView-based (option C — Ionic, Cordova, Capacitor): a web app (HTML/CSS/JS) running inside a native WebView container. Easiest code sharing, but performance and UX can feel "webby". PWA (option D): a website with a service worker and manifest that can be installed on the home screen, works offline. Not a native app — lives in the browser. Flutter is a fifth category: Dart-based framework by Google that compiles to native ARM code and draws its own widgets using Skia/Impeller — not native components, but high-performance custom rendering.
2 / 30
An iOS developer says: "When the user swipes the app away, it goes to the background. If the system is low on memory it might be terminated — our app needs to save state before that happens." What concept is the developer describing?
The app lifecycle describes the states a mobile app transitions through during its lifetime. iOS app lifecycle states: Not running → Active (foreground, handling events) → Inactive (transitioning, e.g., phone call interruption) → Background (running code but not visible) → Suspended (app frozen, memory may be reclaimed). Android lifecycle (Activity/Fragment): onCreate → onStart → onResume (running) → onPause → onStop → onDestroy. Key practice: save user state in applicationWillResignActive (iOS) / onPause (Android) before the app may be killed. Background fetch (option C): a specific iOS feature allowing apps to periodically download content in the background — different from lifecycle state management. Memory leak (option A): memory that's allocated but never freed — causes the app to use increasing RAM over time, which may eventually trigger the OS to kill the app, but is a separate concept from lifecycle management. Lifecycle vocabulary in conversation: "We need to handle the onResume callback to refresh stale data after the user returns from the camera intent."
3 / 30
A product manager asks the team: "Can we open the in-app chat screen directly when the user taps the push notification — even if the app isn't open?" What is this feature called?
A deep link is a URL that navigates a user to a specific screen inside a mobile app — bypassing the home screen or app root. Types: Custom URL scheme (option D): protocol registered by the app, e.g., myapp://chat/123. Simple but limited to devices that have the app installed. Universal Links (iOS) / App Links (Android): standard HTTPS URLs (https://example.com/chat/123) that open the app if installed, or the website if not. More secure and SEO-friendly. Deferred deep link: directs users to the app store if the app isn't installed, then opens the correct screen after install — used in marketing campaigns. Intent filter (option C): the Android mechanism that declares which URL patterns an Activity handles — not the name of the end-user feature, but the implementation mechanism. Deep links usage: push notification payloads include a deep link URL; when tapped, the OS routes to the matching app screen. In conversation: "QR codes in the packaging deep-link to the product page in the app — and fall back to the mobile web page if the app isn't installed."
4 / 30
A mobile team member explains a testing process: "Before we distribute the build to testers, we run it on the Android Emulator and the iOS Simulator to catch obvious crashes, then we send the build to our beta testers via TestFlight." What is the difference between an emulator and a simulator?
The terminology distinction: Emulator (Android Emulator): simulates the entire device including the hardware layer — CPU, memory, sensors. Runs actual ARM binaries. More faithful to the real device, slower to start. Simulator (iOS Simulator): replicates the software environment and UI behaviour but runs compiled x86/x86_64 code on the Mac CPU — does not simulate ARM hardware. Faster and lighter, but may miss hardware-specific bugs (Metal GPU rendering, Bluetooth, biometrics). Practical consequence: you can test camera, cellular, and GPS edge cases more reliably on a real device or Android Emulator. iOS Simulator cannot simulate some hardware features at all (e.g., Face ID only simulates success/fail, not actual biometric processing). Related vocabulary: TestFlight (option D mentions) — Apple's official beta testing distribution platform. Firebase App Distribution — Google's equivalent for Android (and iOS). APK / IPA — Android Package / iOS App Archive (the distributable build artefacts). In conversation: "The crash only reproduces on a real device — it doesn't show up in the Simulator because it's a Metal rendering issue."
5 / 30
A mobile architect explains a decision: "We use an SDK provided by the payment provider — it handles PCI compliance, tokenisation, and the native payment sheet UI. We don't write any payment logic ourselves." What is an SDK in the context of mobile development?
An SDK (Software Development Kit) is a collection of tools, libraries, APIs, sample code, and documentation that enables developers to build on top of a platform or integrate a third party service. In mobile development, SDKs are ubiquitous: Payment SDKs: Stripe SDK, Braintree SDK, Apple Pay / Google Pay — handle payment flows without exposing raw card data to the app. Analytics SDKs: Firebase Analytics, Mixpanel, Amplitude — track user behaviour. Push notification SDKs: Firebase Cloud Messaging (FCM) — receive and display push notifications. Authentication SDKs: Auth0, Firebase Auth — handle OAuth flows, biometric login. Maps SDKs: Google Maps SDK, Mapbox — render maps and routing in-app. Crash reporting SDKs: Sentry, Crashlytics — capture crashes and exceptions automatically. SDK vs. API: An API is the interface (set of endpoints/functions). An SDK is a packaged implementation that makes using the API easier — wrapping HTTP calls, handling auth, providing platform-native UI components, and reducing boilerplate. In conversation: "Integrating the Braintree SDK took two days — building the same PCI-compliant payment flow ourselves would take months."
6 / 30
Sarah (Lead Mobile Developer): "Hey team, I'm seeing a lot of 'memory leaks' reported in the iOS builds. Specifically, the image caching layer seems to be growing unbounded. We need to implement a mechanism to limit the size of this cache and aggressively remove old images when memory pressure increases."
What best describes the problem Sarah is highlighting?
Sarah's concern centers on uncontrolled memory growth. A 'memory leak' occurs when an application allocates memory but doesn't release it properly, leading to performance degradation and eventually crashes. Implementing a cache size limit directly addresses this core issue, preventing excessive memory consumption.
7 / 30
Mark (Senior Android Developer) is responding to a code review comment on his PR:
'This method returns a raw JSON string. It's not ideal for handling complex data structures and doesn't provide any validation. Consider using a dedicated API client library like Retrofit or Volley to handle network requests and ensure proper data parsing.'
What does Mark's comment primarily suggest?
Mark is advocating for best practices in handling network requests. Using an API client library like Retrofit or Volley provides built-in features for parsing JSON responses, managing connections, and validating data – significantly reducing development time and potential errors compared to a custom solution.
8 / 30
David (Mobile Architect): "To ensure our app's responsiveness, we're leveraging asynchronous operations for most of our network calls. This means the UI won't freeze while waiting for data to load."
What is David referring to when he mentions 'asynchronous operations'?
'Asynchronous operations' are crucial for maintaining a responsive UI in mobile applications. Non-blocking operations allow the application to continue executing other tasks while waiting for network responses, preventing UI freezes and improving user experience. Callback mechanisms typically manage these asynchronous events.
9 / 30
Emily (Mobile Developer): "I'm trying to debug a situation where the app crashes when I try to upload a large image. The logs show that the upload operation is timing out before it completes."
What is the most likely cause of this issue?
File size limitations are a common cause of upload timeouts. When an image exceeds the maximum supported size, the upload operation will likely time out before it can complete successfully. This is often coupled with network instability – but the file size itself triggers the timeout.
10 / 30
Ben (Mobile Developer): "We're using a dependency injection framework to manage our UI components and network services. This allows us to easily swap out implementations during testing – it's great for unit tests."
What is the primary benefit of using a dependency injection framework in this context?
A key advantage of dependency injection is its ability to create loosely coupled components. This allows developers to easily mock or stub dependencies during testing, isolating the component under test and facilitating effective unit tests – crucial for robust mobile development.
11 / 30
Sarah (Lead Mobile Developer): "Hey team, I'm seeing a lot of 'memory leaks' reported in the iOS builds. Specifically, the image caching layer seems to be growing unbounded. We need to implement a mechanism to limit the size of this cache and aggressively remove old images when memory pressure increases."
What best describes the problem Sarah is highlighting?
Sarah's concern centers on uncontrolled memory growth. A 'memory leak' occurs when an application allocates memory but doesn't release it properly, leading to performance degradation and eventually crashes. Implementing a cache size limit directly addresses this core issue, preventing excessive memory consumption.
12 / 30
Mark (Senior Android Developer) is responding to a code review comment on his PR:
'This method returns a raw JSON string. It's not ideal for handling complex data structures and doesn't provide any validation. Consider using a dedicated API client library like Retrofit or Volley to handle network requests and ensure proper data parsing.'
What does Mark's comment primarily suggest?
Mark is advocating for best practices in handling network requests. Using an API client library like Retrofit or Volley provides built-in features for parsing JSON responses, managing connections, and validating data – significantly reducing development time and potential errors compared to a custom solution.
13 / 30
David (Mobile Architect): "To ensure our app's responsiveness, we're leveraging asynchronous operations for most of our network calls. This means the UI won't freeze while waiting for data to load."
What is David referring to when he mentions 'asynchronous operations'?
'Asynchronous operations' are crucial for maintaining a responsive UI in mobile applications. Non-blocking operations allow the application to continue executing other tasks while waiting for network responses, preventing UI freezes and improving user experience. Callback mechanisms typically manage these asynchronous events.
14 / 30
Emily (Mobile Developer): "I'm trying to debug a situation where the app crashes when I try to upload a large image. The logs show that the upload operation is timing out before it completes."
What is the most likely cause of this issue?
File size limitations are a common cause of upload timeouts. When an image exceeds the maximum supported size, the upload operation will likely time out before it can complete successfully. This is often coupled with network instability – but the file size itself triggers the timeout.
15 / 30
Ben (Mobile Developer): "We're using a dependency injection framework to manage our UI components and network services. This allows us to easily swap out implementations during testing – it's great for unit tests."
What is the primary benefit of using a dependency injection framework in this context?
A key advantage of dependency injection is its ability to create loosely coupled components. This allows developers to easily mock or stub dependencies during testing, isolating the component under test and facilitating effective unit tests – crucial for robust mobile development.
16 / 30
Sarah (Lead Mobile Developer): "Hey team, I'm seeing a lot of 'memory leaks' reported in the iOS builds. Specifically, the image caching layer seems to be growing unbounded. We need to implement a mechanism to limit the size of this cache and aggressively remove old images when memory pressure increases."
What best describes the problem Sarah is highlighting?
Sarah's concern centers on uncontrolled memory growth. A 'memory leak' occurs when an application allocates memory but doesn't release it properly, leading to performance degradation and eventually crashes. Implementing a cache size limit directly addresses this core issue, preventing excessive memory consumption.
17 / 30
Mark (Senior Android Developer) is responding to a code review comment on his PR:
'This method returns a raw JSON string. It's not ideal for handling complex data structures and doesn't provide any validation. Consider using a dedicated API client library like Retrofit or Volley to handle network requests and ensure proper data parsing.'
What does Mark's comment primarily suggest?
Mark is advocating for best practices in handling network requests. Using an API client library like Retrofit or Volley provides built-in features for parsing JSON responses, managing connections, and validating data – significantly reducing development time and potential errors compared to a custom solution.
18 / 30
David (Mobile Architect): "To ensure our app's responsiveness, we're leveraging asynchronous operations for most of our network calls. This means the UI won't freeze while waiting for data to load."
What is David referring to when he mentions 'asynchronous operations'?
'Asynchronous operations' are crucial for maintaining a responsive UI in mobile applications. Non-blocking operations allow the application to continue executing other tasks while waiting for network responses, preventing UI freezes and improving user experience. Callback mechanisms typically manage these asynchronous events.
19 / 30
Emily (Mobile Developer): "I'm trying to debug a situation where the app crashes when I try to upload a large image. The logs show that the upload operation is timing out before it completes."
What is the most likely cause of this issue?
File size limitations are a common cause of upload timeouts. When an image exceeds the maximum supported size, the upload operation will likely time out before it can complete successfully. This is often coupled with network instability – but the file size itself triggers the timeout.
20 / 30
Ben (Mobile Developer): "We're using a dependency injection framework to manage our UI components and network services. This allows us to easily swap out implementations during testing – it's great for unit tests."
What is the primary benefit of using a dependency injection framework in this context?
A key advantage of dependency injection is its ability to create loosely coupled components. This allows developers to easily mock or stub dependencies during testing, isolating the component under test and facilitating effective unit tests – crucial for robust mobile development.
21 / 30
Sarah (Lead Mobile Developer): "Hey team, I'm seeing a lot of 'memory leaks' reported in the iOS builds. Specifically, the image caching layer seems to be growing unbounded. We need to implement a mechanism to limit the size of this cache and aggressively remove old images when memory pressure increases."
What best describes the problem Sarah is highlighting?
Sarah's concern centers on uncontrolled memory growth. A 'memory leak' occurs when an application allocates memory but doesn't release it properly, leading to performance degradation and eventually crashes. Implementing a cache size limit directly addresses this core issue, preventing excessive memory consumption.
22 / 30
Mark (Senior Android Developer) is responding to a code review comment on his PR:
'This method returns a raw JSON string. It's not ideal for handling complex data structures and doesn't provide any validation. Consider using a dedicated API client library like Retrofit or Volley to handle network requests and ensure proper data parsing.'
What does Mark's comment primarily suggest?
Mark is advocating for best practices in handling network requests. Using an API client library like Retrofit or Volley provides built-in features for parsing JSON responses, managing connections, and validating data – significantly reducing development time and potential errors compared to a custom solution.
23 / 30
David (Mobile Architect): "To ensure our app's responsiveness, we're leveraging asynchronous operations for most of our network calls. This means the UI won't freeze while waiting for data to load."
What is David referring to when he mentions 'asynchronous operations'?
'Asynchronous operations' are crucial for maintaining a responsive UI in mobile applications. Non-blocking operations allow the application to continue executing other tasks while waiting for network responses, preventing UI freezes and improving user experience. Callback mechanisms typically manage these asynchronous events.
24 / 30
Emily (Mobile Developer): "I'm trying to debug a situation where the app crashes when I try to upload a large image. The logs show that the upload operation is timing out before it completes."
What is the most likely cause of this issue?
File size limitations are a common cause of upload timeouts. When an image exceeds the maximum supported size, the upload operation will likely time out before it can complete successfully. This is often coupled with network instability – but the file size itself triggers the timeout.
25 / 30
Ben (Mobile Developer): "We're using a dependency injection framework to manage our UI components and network services. This allows us to easily swap out implementations during testing – it's great for unit tests."
What is the primary benefit of using a dependency injection framework in this context?
A key advantage of dependency injection is its ability to create loosely coupled components. This allows developers to easily mock or stub dependencies during testing, isolating the component under test and facilitating effective unit tests – crucial for robust mobile development.
26 / 30
Sarah (Lead Mobile Developer): "Hey team, I'm seeing a lot of 'memory leaks' reported in the iOS builds. Specifically, the image caching layer seems to be growing unbounded. We need to implement a mechanism to limit the size of this cache and aggressively remove old images when memory pressure increases."
What best describes the problem Sarah is highlighting?
Sarah's concern centers on uncontrolled memory growth. A 'memory leak' occurs when an application allocates memory but doesn't release it properly, leading to performance degradation and eventually crashes. Implementing a cache size limit directly addresses this core issue, preventing excessive memory consumption.
27 / 30
Mark (Senior Android Developer) is responding to a code review comment on his PR:
'This method returns a raw JSON string. It's not ideal for handling complex data structures and doesn't provide any validation. Consider using a dedicated API client library like Retrofit or Volley to handle network requests and ensure proper data parsing.'
What does Mark's comment primarily suggest?
Mark is advocating for best practices in handling network requests. Using an API client library like Retrofit or Volley provides built-in features for parsing JSON responses, managing connections, and validating data – significantly reducing development time and potential errors compared to a custom solution.
28 / 30
David (Mobile Architect): "To ensure our app's responsiveness, we're leveraging asynchronous operations for most of our network calls. This means the UI won't freeze while waiting for data to load."
What is David referring to when he mentions 'asynchronous operations'?
'Asynchronous operations' are crucial for maintaining a responsive UI in mobile applications. Non-blocking operations allow the application to continue executing other tasks while waiting for network responses, preventing UI freezes and improving user experience. Callback mechanisms typically manage these asynchronous events.
29 / 30
Emily (Mobile Developer): "I'm trying to debug a situation where the app crashes when I try to upload a large image. The logs show that the upload operation is timing out before it completes."
What is the most likely cause of this issue?
File size limitations are a common cause of upload timeouts. When an image exceeds the maximum supported size, the upload operation will likely time out before it can complete successfully. This is often coupled with network instability – but the file size itself triggers the timeout.
30 / 30
Ben (Mobile Developer): "We're using a dependency injection framework to manage our UI components and network services. This allows us to easily swap out implementations during testing – it's great for unit tests."
What is the primary benefit of using a dependency injection framework in this context?
A key advantage of dependency injection is its ability to create loosely coupled components. This allows developers to easily mock or stub dependencies during testing, isolating the component under test and facilitating effective unit tests – crucial for robust mobile development.
What does the "Mobile Development Vocabulary" vocabulary exercise cover?
This exercise tests real IT vocabulary related to mobile development vocabulary through 30 multiple-choice questions, each built from realistic workplace sentences rather than abstract definitions.
Is this vocabulary exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is completely free — no account, sign-up, or payment required.
How many questions does this exercise have?
This exercise has 30 questions. Each one shows a real-world sentence or scenario with multiple-choice options and an explanation once you answer.
What happens after I answer a question?
You'll see immediate feedback showing whether your answer was correct, along with a short explanation of why — then a button to move to the next question, and a full results screen at the end.
Can I retry the exercise if I get questions wrong?
Yes. Once you reach the results screen, click "Try again" to reset your answers and go through the exercise from the start as many times as you like.
Do I need to create an account to take this exercise?
No account is needed. Your answers are scored in your browser during the session — nothing is saved to a server, so you can jump straight in.
Is my progress saved if I leave the page?
No — progress within an exercise resets if you navigate away or reload. Each exercise is short enough to complete in a few minutes in one sitting.
Are these vocabulary exercises connected to other topics?
Yes — browse the full vocabulary exercises hub to find related modules covering adjacent IT topics and roles.
How is this different from reading a glossary or blog article?
Exercises like this one are active recall drills — you have to choose the correct term or phrasing yourself, which builds retention faster than passively reading a definition.
Where can I find more vocabulary exercises?
Browse the full Vocabulary exercises hub for hundreds of modules covering Agile, DevOps, security, databases, architecture, and more — organised by IT role and skill.