Skip to content

Programming iOS Android Backend Patterns Coding System design Interview Glossary

Menu

Variables, types and type inference
Control flow and pattern matching
Functions, closures and lambdas
Null Safety: Optionals and Nullable Types
Collections and functional operations
Classes, inheritance and interfaces
Value types vs reference types
Generics
Error handling
Enums and sealed hierarchies
Extensions
Memory: ARC vs garbage collection
Concurrency: async/await, coroutines and virtual threads
Immutability
Unit testing

iOS Development

SwiftUI Basics
State and Data Flow
Lists and navigation
Networking with URLSession and Codable
Swift Concurrency: actors and Sendable
Persistence with SwiftData
UIKit for SwiftUI developers
Architecture: MVVM, TCA and coordinators
Dependency injection
Testing with Swift Testing and UI tests
Performance and Instruments
Memory leaks and retain cycles
App lifecycle and background tasks
Push notifications
Accessibility
TestFlight and App Store release

Android Development

Kotlin for Android
Jetpack Compose Basics
State and Recomposition
Activity lifecycle and configuration changes
ViewModel and unidirectional data flow
Coroutines and Flow
Navigation
Networking with Retrofit and Ktor
Room database
Dependency injection with Hilt
WorkManager and background work
Architecture: MVVM, MVI and Clean
Testing
Performance and baseline profiles
Permissions and notifications
Google Play release and R8

Modern Java: records, sealed types and virtual threads
Spring Boot Basics
Building a REST API
JPA and Hibernate
Transactions
Spring Security, JWT and OAuth2
Testing with JUnit, Mockito and Testcontainers
Configuration and profiles
Caching with Redis
Messaging with Kafka
Observability: logs, metrics and tracing
Docker and deployment
JVM performance and garbage collection

Design Patterns

SOLID Principles
Singleton
Factory Method
Abstract Factory
Builder
Prototype
Adapter
Decorator
Facade
Proxy
Composite
Strategy
Observer
Command
State
Template Method
Chain of Responsibility
Iterator
MVC, MVP, MVVM and MVI
Repository
Coordinator
Dependency injection
Unidirectional data flow

Coding Interview

How coding interviews work
Big-O notation
Arrays and strings
Hash Maps
Two pointers
Sliding window
Stacks and queues
Linked lists
Binary search
Trees: DFS and BFS
Graphs
Heaps
Backtracking
Dynamic programming
Greedy algorithms
Intervals

How System Design Interviews Work
Scaling and load balancing
Caching
Databases: SQL, NoSQL, indexes and sharding
Replication and consistency
CAP theorem
Message queues
CDNs
Rate limiting
API design: REST, GraphQL and gRPC
Design a URL Shortener
Design a chat app
Design a news feed
Design a notification system
Design a rate limiter
Design file upload
Mobile: offline-first and sync
Mobile: image loading and caching
Mobile: pagination and real-time updates

Interview Questions

Bites: quick review Your progress

Commitwise Bites: daily review of your lessons

Review

0

Loading cards…

Esc

Type to search the whole site.