Advanced Mobile Programming — Terms & Concepts

Vocabulary flashcards covering core Flutter concepts, widget categories, navigation mechanisms, state management patterns, asynchronous programming, REST and Web APIs, JSON, and Firebase architecture.

Design pattern

A reusable blueprint for solving a common problem in software development that provides an adaptable approach or structure rather than a complete code solution.

MVC (Model-View-Controller)

An architectural and design pattern developed by Trygve Reenskaug that separates an application into three logical components: model, view, and controller.

Cross-platform development

Creating software that runs on multiple platforms or operating systems from a single codebase without rewriting code for each one.

Framework

A foundation structure and collection of components or technologies that speeds up application development by providing a template to fit the project.

Dart

A general-purpose, object-oriented programming language developed by Google, characterized by clean syntax, strong typing, and cross-platform compilation.

Flutter

An open-source UI framework created by Google for developing high-performance, cross-platform applications across mobile, web, desktop, and embedded devices from a single codebase.

Basic widgets

Fundamental building blocks in Flutter for displaying content, including Text, Container, Row, Column, Image, and IconButton.

Layout widgets

Widgets that arrange other widgets on the screen, such as Row (horizontal), Column (vertical), and Stack (overlapping).

Material widgets

Android-inspired Flutter widgets that follow Google's design guidelines, such as Scaffold, AppBar, and FloatingActionButton.

Cupertino widgets

iOS-inspired Flutter widgets that follow Apple's design language, such as CupertinoButton.

Custom widgets

Reusable UI components created by extending the Flutter Widget class, such as CustomText or custom dialog builders.

Stack navigation

The most common navigation approach where screens are pushed onto a stack and popped off to return; ideal for linear flows and hierarchical structures.

Tab navigation

A navigation pattern for switching between independent sections, typically utilizing tabs located at the bottom.

Bottom navigation

A navigation structure similar to tab navigation, often featuring a circular layout and animation for a modern feel.

Drawer navigation

A hidden menu that slides in from the side, typically used for less frequently accessed navigation options.

Navigator

The core Flutter widget for managing the navigation stack and transitions between different screens.

MaterialPageRoute

A common route definition for pushing new screens using platform-specific animations suited for Android-style apps.

CupertinoPageRoute

A route definition for pushing new screens that provides Cupertino-style animations for iOS-inspired apps.

Named routes

Routes defined using string names to facilitate easier screen navigation and clean code organization.

Stateless widget

The simplest building block in Flutter that holds no state, maintaining a constant appearance that only changes if its parent rebuilds.

Stateful widget

A widget that maintains and modifies mutable state over time, enabling dynamic UI updates triggered by user interaction, data changes, or events.

createState()

A lifecycle method called when a StatefulWidget is first inserted into the tree; returns a State object holding the widget's mutable state.

initState()

A lifecycle method called immediately after createState() for one-time initialization such as setting state variables or subscribing to streams; called only once.

didChangeDependencies()

A lifecycle method invoked immediately after initState() and whenever the widget's dependencies change, such as an InheritedWidget or locale update.

build()

A lifecycle method called to construct the widget's UI, executing every time state changes or when the widget is rebuilt.

didUpdateWidget()

A lifecycle method called whenever the widget's parent rebuilds and provides new configuration properties to the widget.

deactivate()

A lifecycle method called when a widget is removed from the widget tree but might potentially be reinserted before the current frame ends.

dispose()

A lifecycle method called when a widget is permanently removed from the tree; serves as the final opportunity to release resources like timers and streams.

RestorationManager

The Flutter class in the services library that resolves state loss when an operating system terminates a backgrounded application.

Instance state

Short-term ephemeral state like unsubmitted form fields or active tabs, limited to 1 MB on Android where exceeding it causes TransactionTooLargeException.

Declarative UI

The architectural paradigm in Flutter where UI is constructed to reflect current state, rebuilding elements from scratch rather than imperatively modifying them.

Immutability of widgets

The principle that Flutter widgets do not mutate; instead of calling update methods, a new widget instance is constructed to replace the old one.

Ephemeral state

Short-lived state localized to a specific widget or small UI segment that exists only while mounted, usually managed via setState inside a StatefulWidget.

App state

State shared across multiple widgets or the entire application, usually long-lived, that requires a dedicated management solution like Provider or BLoC.

Lifting state up

The practice of locating state in an ancestor widget above the widgets that consume it, ensuring child widgets only have a single build code path.

InheritedWidget

A low-level Flutter mechanism that allows widgets to efficiently provide data and services downwards to all descendant widgets in the tree.

ChangeNotifier

A class from flutter:foundation that provides change notifications to listeners as an Observable, commonly used to encapsulate application state.

notifyListeners()

The method invoked inside a ChangeNotifier model to notify all listening widgets that state has changed and a UI rebuild is needed.

ChangeNotifierProvider

A widget from the provider package that provides an instance of a ChangeNotifier to its descendants and handles its automatic disposal.

Consumer

A widget from the provider package used to access a provided model, rebuilding only its builder callback subtree when the model changes.

Provider.of with listen: false

A method to read or interact with a provided model without subscribing the calling widget to rebuilds when notifyListeners() is called.

Back-end

The server-side component of an application invisible to users, responsible for APIs, database management, security, and application logic.

Asynchronous programming

A programming style allowing tasks to run concurrently in the background without blocking the execution of the main thread.

Future

An object representing a computation that will finish later, encapsulating an eventual success value or an error.

async

A Dart keyword marking a function as asynchronous, enabling non-blocking execution and implicitly causing it to return a Future.

await

A keyword that halts execution within an async function until the target Future completes and returns its resolved value.

FutureBuilder

A Flutter widget that builds its UI based on the latest interaction snapshot with a Future, updating across various ConnectionState stages.

ConnectionState

An enum representing the current state of an asynchronous operation in Flutter, comprising four values: none, waiting, active, and done.

API (Application Programming Interface)

A software intermediary enabling communication and data exchange between applications, acting as a machine-to-machine interface.

RPC (Remote Procedure Call)

A Web API type that enables client applications to call functions directly on a remote server.

RMI (Remote Method Invocation)

A Web API type that allows client applications to invoke methods on remote server objects.

REST (Representational State Transfer)

An architectural style for distributed hypermedia systems described by Roy Thomas Fielding in 2000, centered on performing CRUD operations on resources.

Six REST constraints

The formal architectural requirements of REST: Client-Server, Stateless, Cache, Uniform Interface, Layered System, and Code-On-Demand.

PATCH

An HTTP method used for applying partial modifications to a resource, distinguished from PUT which updates or replaces the full resource.

JSON (JavaScript Object Notation)

A lightweight, text-based data interchange format created by Douglas Crockford with the media type application/json and file extension .json.

Firebase

A Backend-as-a-Service (BaaS) platform by Google providing pre-built backend services including realtime databases, auth, and analytics.

Cloud Firestore

A flexible, scalable NoSQL cloud database service from Firebase, accessed in Flutter via the cloud_firestore package.

Realtime Database

A Firebase cloud database that stores and synchronizes data across clients in real time using the firebase_database package.

Firebase Cloud Messaging (FCM)

A cross-platform messaging service provided by Firebase for sending push notifications, integrated via the firebase_messaging package.

Trygve Reenskaug

The computer scientist who originally developed the Model-View-Controller (MVC) architectural pattern.

Roy Thomas Fielding

The computer scientist who described the REST (Representational State Transfer) architectural style in his 2000 doctoral dissertation.

Douglas Crockford

The computer programmer who introduced and standardized JSON (JavaScript Object Notation) in the early 2000s.