Flutter Developer Cheat Sheet Vocabulary

Vocabulary flashcards covering software design patterns, app architectures, Dart language features, testing types, and core Flutter concepts.

Flutter

A free and open-source mobile UI framework created by Google and released in May 2017 that allows developers to create native mobile applications using a single codebase.

Encapsulation

The process of packaging data and related code into a single object to ensure data protection and prevent unintended access or modifications.

Abstraction

The process of hiding implementation details and data so programmers can focus on overall program logic.

Inheritance

An Object-Oriented Programming principle allowing lower classes in a hierarchy to inherit variables and methods from their parent class.

Polymorphism

The ability of different objects to respond differently to the same method call.

Hot Reload

A feature in Flutter that applies modified code changes instantly within the application.

Single-responsibility principle

A SOLID principle stating that every class should have only one responsibility and only one reason to change.

Open–closed principle

A SOLID principle stating software entities should be open for extension, but closed for modification.

Liskov substitution principle

A SOLID principle stating that functions using pointers or references to base classes must be able to use objects of derived classes without knowing it.

Interface segregation principle

A SOLID principle stating that clients should not be forced to depend upon interfaces that they do not use.

Dependency inversion principle

A SOLID principle stating that code should depend upon abstractions rather than concretions.

Dependency injection

A software design pattern where required objects are provided to instantiate a new object so that the new object does not need to construct or customize those dependencies itself.

Observer pattern

A design pattern defining a one-to-many dependency between objects where dependents are automatically notified and updated when state changes occur.

Factory

A design pattern where a factory class controls object creation and instantiation logic without specifying concrete classes directly.

MVC

An app architecture pattern composed of Model (data/data access layer), View (graphic display of data), and Controller (glue that alters Model based on View activity and updates View).

MVVM

An app architecture pattern consisting of Model, View, and ViewModel, where ViewModel serves as mediator and binds data and user action updates between View and ViewModel.

Presenter (MVP)

The MVP component responsible for querying the model and translating updates in the view, as the view lacks direct access to the model.

Clean Architecture

A concept describing how various app layers (business objects, use cases, presenters, data storage, and UI) communicate, placing MVC and MVVM at the outer presentation and UI layers.

Unit test

A test that verifies the correctness of a single function, method, or class under a variety of conditions, with external dependencies mocked out.

Widget test

A test (also called a component test) that verifies a single widget's UI appearance and interaction within a simplified lifecycle context environment.

Integration test

A test that verifies that all widgets and services in a complete app or large app segment work together on a real device or emulator.

Testing Trade-offs Comparison

A breakdown comparing Unit, Widget, and Integration tests in terms of Confidence, Maintenance cost, Dependencies, and Execution speed.

Isolate

An independent thread in Dart that does not share memory with the main thread and communicates exclusively via messages.

Future

A Dart object representing a single asynchronous value or error retrieved using async/await or .then callbacks.

Stream

A Dart object that returns 0 or more values asynchronously over time using async* and yield.

Broadcast stream

A type of Stream that supports multiple attached listeners simultaneously.

Widget (Flutter)

An immutable description of a part of a user interface that describes configuration for an Element.

Element (Flutter)

An instance of a widget at a specific location in the tree that handles tree references and configuration.

RenderObject

An object in the render tree responsible for laying out and painting widgets displayed on screen as directed by the Element tree.

Mixins

A Dart construct declared with mixin or mixin class that defines reusable code across class hierarchies using the with keyword.

StatelessWidget

A Flutter widget that requires no mutable state and relies entirely on configuration information in itself and its BuildContext.

StatefulWidget

A Flutter widget with mutable state stored in a separate State object created via createState.

InheritedWidget

A base class widget that efficiently passes data down the widget tree to descendant children without manual constructor passing.

BuildContext

A locator unique to each widget that tracks its location and position within the widget tree.

Keys

Identifiers used in Flutter to preserve widget state and prevent unnecessary widget rebuilds.

List (Dart)

An ordered sequence of elements that can be fixed length or growable.

Set (Dart)

An unordered collection of unique values of the same type that disallows duplicate entries.

Map (Dart)

A key-value collection where each key is unique and associated with a value.

Queue (Dart)

A FIFO (First In First Out) data structure in Dart where elements added first are removed first.

var (Dart)

A keyword used to declare a variable whose type is inferred and fixed at compile time, preventing runtime type changes.

dynamic (Dart)

A type setting that disables type checking completely, allowing a variable to be reassigned to any data type at runtime.

Object (Dart)

The root class of the Dart type hierarchy that restricts method calls to those explicitly defined on Object.

final (Dart)

A variable modifier requiring single assignment via an initializer whose value cannot be reassigned once set.

const (Dart)

A modifier for values and objects that makes their entire deep state compile-time frozen and immutable.

hashCode

A single integer value representing the state of an object that affects operator == comparisons.

AOT Compilation (Dart)

Ahead-Of-Time compilation mode offering fast application startup and lower memory usage, but without runtime profiling optimization.

JIT Compilation (Dart)

Just-In-Time compilation mode using runtime profiling data for specific optimizations, but requiring longer startup and warmup periods.

Event Loop

The mechanism in Dart that processes asynchronous execution and queues in a non-blocking manner.

Event Queue

A Dart Event Loop queue containing outside events such as I/O, mouse actions, timers, drawing events, and inter-isolate messages.

Microtask Queue

A Dart Event Loop queue reserved for short internal asynchronous actions that execute before the Event Queue turns.