Easy concepts in Mobile Dev
React Native Core Components: Your UI Building Blocks
Think of Core Components as React Native's built-in LEGO bricks for UIs, translating your code into native Android and iOS views. Use them for layouts (View), text (Text), and lists (FlatList). The footgun: never use ScrollView for long lists.
Variables and Constants in Swift
Swift has two ways to store a value: var declares a variable you can reassign later, and let declares a constant whose value is set once and can never change, and Swift's convention is to default to let unless you have a specific reason to need var.
Dart Variables: var, final, and const
In Dart, var creates a mutable variable, while final and const are for single-assignment. Use var for changing state, final for runtime values set once, and const for compile-time constants. The footgun is confusing final with const.
Kotlin Variables: `val` for Constants, `var` for Variables
In Kotlin, val creates a read-only constant you assign once, like a fixed setting. var creates a mutable variable you can change later. Always prefer val unless you explicitly need to reassign a value to prevent accidental state changes.
Styling in React Native with StyleSheet
StyleSheet is React Native's answer to CSS, defining styles in JavaScript to separate presentation from logic. Use StyleSheet.create() to define reusable style objects that get static type checking. The footgun is styling inline, which hurts performance.
Swift Control Flow: Directing Your Code's Path
Control flow statements are the traffic signals of your code. They use keywords like if, for, and switch to make decisions and repeat actions, rather than just running top-to-bottom. This is how you show a list of items or check if a user is logged.
Dart's Core Data Types: Everything is an Object
In Dart, everything is an object, from numbers to functions. This means even a simple int or String has methods and properties, unlike primitive types in other languages. The main footgun is forgetting that null itself is a type, Null.
Kotlin Null Safety: Catch Nulls at Compile Time
Kotlin's type system catches null pointer errors at compile time. Variables are non-nullable by default; you must opt-in to nulls with a ? (e.g., String?). The compiler then forces you to handle the null case. The main footgun is the !! operator.
Kotlin's Control Flow Expressions: `if` and `when`
In Kotlin, if and when are expressions that return a value. This lets you assign their result directly to a variable, replacing Java's ternary operator. The footgun: when used as an expression, you must have an else branch to cover all cases.
Flexbox: Responsive Layouts in React Native
Flexbox arranges components along a primary axis, creating responsive UIs without manual calculations. It's used for nearly all layout needs, from centering items to building complex grids.
Dart's Control Flow: Telling Your Code What to Do Next
Control flow statements are the road signs for your code, directing execution beyond a simple top-to-bottom path. Use if/else for decisions, for/while for loops, and try/catch to handle errors. The footgun is forgetting break in a switch case.
Dart Function Syntax: Block Body vs. Arrow Notation
Dart functions use a block body {} for multiple statements or arrow syntax => for a single expression. Use => for simple one-liners like bool isEven(int n) => n % 2 == 0;. The footgun is using => for multi-step logic; it only works for.
Kotlin Functions: Named, Reusable Code Blocks
A function is a named recipe for your code. You give it ingredients (parameters) and it produces a result. They are used everywhere, from calculating values to handling button clicks.
Value vs. Reference Semantics in Swift
Value types are like emailing a document copy; changes don't affect the original. Reference types are like a shared Google Doc link; everyone edits the same instance. In Swift, structs are copies, while classes are shared references.
The View Component: React Native's UI Building Block
Think of View as the <div> of React Native. It’s the fundamental container for grouping and styling other components, used everywhere to structure layouts with flexbox. The footgun: Text must be in a <Text> component, not directly in a View.
The Result Type: Modeling Success and Failure
The Result type is a sealed box for an operation's outcome: it holds either a success value or a failure error. It's used in asynchronous code like network requests to create clean, explicit completion handlers. The footgun is forgetting to handle both cases.
React Native's Text Component: Beyond Displaying Words
The React Native <Text> component creates a special text layout context, not a Flexbox one. Use it for all text, nesting components to style parts of a sentence.
Protocol Extensions: Default Behavior for Free
Protocol extensions give conforming types default functionality "for free," like a standard toolkit with every blueprint. Use them to add common behavior to your protocols or even extend system types.
Coroutine Dispatchers: Telling Your Coroutines Which Thread to Use
A Dispatcher tells a coroutine which thread or thread pool to use for its work. Use Dispatchers.Default for CPU-intensive tasks. If none is specified, it inherits from its parent. The main footgun: Unconfined can resume on an unexpected thread.
React Native's Image Component
The Image component is React Native's tool for displaying pictures from network URLs, local app assets, or the device's camera roll. The biggest footgun: you must manually set width and height for any image loaded from a URL or it won't appear.
We are hiring for this. Every open role lists the topics its interview covers, so you can prepare for the real thing rather than guessing.
See open roles