Book
  • Introduction
  • Welcome !!
  • Chapter 1: The mobile ecosystem
    • Fragmentation is the devil
    • There is more than one type of mobile app
    • ... more than one type of app
    • ... one type of app
    • Under pressure (ee da de da de) !!
    • Further reading!!
  • Chapter 2: Let's start with design thinking
    • A taste of design thinking
    • The five steps
    • Design for everybody
    • Accessibility in mobile apps
  • Chapter 3: Give me a context and I will give you an app
    • Users
    • Personas? Users ? What is the difference?
    • Please, help me to model the context
    • The context canvas
  • Chapter 4: Powerful models
    • Data architecture is the foundation of analytics
    • From data to information and knowledge
    • Information/Knowledge in our mobile ecosystem
    • Questions to ask yourselves when building and classifying questions
    • The visualization-data map
    • On the scene: describing how personas interact with your app
  • Chapter 5: A GUI is better than two thousand words
    • 'Good to Go:' Let's explore the Design Systems
    • Designing GUI Mocks
    • No prototype... no deal
  • Chapter 6: About mobile operating systems ... and other deamons
    • The Android OS ... son of LINUX
    • iOS son of Darwin? or is it iOS son of UNIX?
    • Kernels
  • Chapter 7: Yes, software architecture matters !!
    • Self-test time
    • About design and design constraints
    • Architects' mojo: styles and patterns
    • What you need is a tactic !!
    • Self-test time 2 (for real)
    • Further reading
  • Chapter 8: Finally... coding
    • MVC, MVVM, MV*, MV...What?
    • Programming models: the Android side
    • Hello Jetpack, my new friend... An Android Jetpack Introduction
    • Programming models: the iOS side
    • Controllers and more controllers
    • Flutter son of... simplicity
    • Programming models: Flutter?
    • Flutter: State matters... Let´s start simple
    • Flutter: State matters... Complex stuff ahead
    • Micro-optimizations
  • Chapter 9: Data pipeline
    • Generalities data pipelines
    • Data storage types
    • Types of data pipelines
  • Chapter 10: Error Retrieving Chapter 10
    • Eventual Connectivity on Mobile Apps
    • How to handle it on Android
  • Chapter 11: The jewel in the crown: Performance
    • As fast as a nail
    • Memory bloats
    • Energy leaks
    • Final thoughts
  • Chapter 12. Become a performance bugs exterminator
    • Weak or strong?
    • Micro-optimizations
    • The single thread game !!
    • Using multi-threading like a boss !!
    • Caching
    • Avoiding memory bloats
    • Further readings
Powered by GitBook
On this page
  1. Chapter 8: Finally... coding

Flutter son of... simplicity

PreviousControllers and more controllersNextProgramming models: Flutter?

Last updated 1 year ago

(By Rogelio GarcĂ­a)


Flutter is a powerful cross-platform mobile app development framework. It's an open-source project created by Google. Check out the . It's made to build beautiful and high-performant apps for both iOS and Android, by using Dart, a language that is quite friendly to start using.

The stack for Flutter is comprised of three main layers. The framework itself, implemented in Dart, the engine on which it runs, implemented mostly in C++, and the actual mobile platforms.

The framework layer

The Flutter framework itself and most of its system is built with Dart. It offers a variety of widgets and themes, means to composite your app, create and handle animations and gestures, etc. This part of Flutter can be edited by developers for more control and customizing. Flutter is also perfectly usable using it out of the box. This is what you'll be using for the most part

The engine layer

The Flutter engine is described as a thin C/C++ layer. It's a shell that includes Skia, Google's graphics rendering library, the Dart VM and other essential technologies. Ultimately, graphics are rendered in C++ in this layer. It also includes isolates (threading) implementation, Dart's runtime library and lifecycle logic.

The engine also defines the Platform-specific channels that allow Flutter devs to implement Dart code that communicates with the Android and iOS shells, bypassing the Flutter Engine. This is particularly useful in cases when something is very platform dependant (for example, Android's interactive notifications), or not implemented in Flutter yet.

The embedder layer

Also, there's an ongoing Flutter web project, but it has a slightly different stack and is being developed on a separate fork of the main Flutter repository. This is the stack for curiosity's sake:

Image based on this by Ralf Gehrer on Medium.

The following detailed stack layer images are based on about the engine architecture.

Image taken from the . You can check it out for more info on channels.

The Embedder layer includes OS shells like Android and iOS (Darwin), however the project envisions other shells like Google's Fuchsia OS, Windows, GLFW (OpenGL) and Linux. You can see this in .

You can even build Flutter outside of these platforms, using . Mind you, this is very advanced, and is not officially supported.

Image based on the , and this on Medium by Google's software engineer, Yegor Jbanov.

article
the Flutter Github wiki article
official docs
Flutter's repo
the embedder API
official docs
article
Flutter website