This article introduces the dart:io library, explaining its purpose, how to import and use it for file and directory manipulation, networking with HttpServer/HttpClient, process management, WebSocket communication, and standard I/O streams, accompanied by practical code examples for Dart and Flutter developers.
Google’s Developer Days in Shanghai introduced Flutter 1.9 and Dart 2.5, highlighting macOS Catalina and iOS 13 support, new Material widgets, experimental Bitcode, expanded language packs, improved toolchains, and the integration of Flutter Web into the main repository, signaling a major step toward true cross‑platform development.
During a three‑month Flutter internship at Xianyu, a Guangdong University of Technology software‑engineering student migrated from Android to Flutter, rebuilt the publishing page with Fish‑Redux, optimized a pull‑to‑refresh widget saving over 100 MB of memory, mastered the full FDD workflow, and distilled a comprehensive learning roadmap and teamwork advice for future developers.
This article explains how Flutter loads and renders a UI by introducing the core concepts of Widget, Element and RenderObject, detailing the framework‑to‑engine rendering pipeline, walking through key source‑code snippets such as runApp, WidgetsFlutterBinding, attachRootWidget and frame scheduling, and discussing performance‑optimising layout boundaries.
Metaprogramming in Dart leverages the Dill intermediate representation and its abstract syntax tree to programmatically generate, transform, or inject code at compile time, enabling features such as custom serialization, AOP hooks, and reflection‑like capabilities without runtime overhead.
Flutter is Google’s UI toolkit that uses the Skia engine and Dart’s AOT/JIT compilation to render directly to a canvas, offering fast, cross‑platform performance, modern language features, flexible state‑management options like setState, InheritedWidget and Bloc, and support for testing, lifecycle handling, and native platform channels for web, desktop, and mobile.
This article explains how Flutter loads and renders UI by detailing the roles of Widgets, Elements, and RenderObjects, the framework and engine layers, the runApp entry process, frame scheduling, layout boundaries, and performance considerations, supplemented with concrete Dart code examples.
This article explains Flutter’s architecture and the complete loading‑to‑display pipeline, covering the Engine and Framework layers, the roles of Widget, Element and RenderObject, and the step‑by‑step execution of runApp, binding initialization, frame scheduling and layout optimization.
This article explains the challenges of applying aspect‑oriented programming in Flutter, introduces the open‑source AspectD framework for Dart, and walks through its design, supported syntax, code examples, and integration steps for both debug and release builds.
This comprehensive guide explains what Flutter plugins are, why they are essential, the MethodChannel communication model, step‑by‑step plugin creation, common pitfalls, testing strategies, publishing to public or private repositories, and a real‑world case study of a routing plugin, providing all the code and configuration details developers need to build and distribute their own Flutter plugins.
The talk describes how Xianyu’s architecture team unified Flutter’s high‑performance, cross‑platform UI with Dart‑based serverless FaaS, using hot‑reload, isolates and C++ extensions to replace traditional native‑web‑backend stacks, cutting a two‑month project by 20 days and streamlining large‑scale app development.
This article details the WeChat client team's evolution from early C99‑based cross‑platform components to a mini‑program‑centric architecture, examines performance challenges on Android, and describes how integrating native rendering, the LV‑CPP C++ layer, and Flutter dramatically improved UI consistency, efficiency, and maintainability across iOS and Android.
AspectD is a compile‑time Aspect‑Oriented Programming framework for Dart that traverses Flutter’s dill intermediate files to inject, call, or execute advice code, allowing non‑intrusive instrumentation, logging, and UI event injection without modifying source, and integrates into the build pipeline via a toolchain patch.
Xianyu’s tech team adopted Dart for a backend glue layer that bridges frontend Flutter clients and Java domain services, leveraging Dart’s familiar syntax, strong async/await support, isolates for rapid hot‑replaceable development, and parallel Future.wait calls to achieve high‑performance, low‑latency APIs with fast deployment.
This article explains Flutter's multithreading model, comparing isolates and event queues to iOS GCD, detailing async/await, Future, coroutine concepts, and the roles of Platform, UI, GPU, and IO runners, with code examples illustrating isolate communication and asynchronous network requests.
The article examines Flutter's rise as a leading cross‑platform mobile framework, compares it with other solutions like Hybrid, React Native, and Qt, explores its ecosystem, and highlights key breakthroughs such as Code‑Push and Hummingbird that could redefine the mobile development landscape.
Evaluating Dart’s AoT, AppJIT, Kernel, and JIT compilation for server‑side FaaS shows AoT yields the fastest runtime (≈6× JIT), AppJIT with aggressive optimization slightly outperforms Kernel, startup latency rivals Java, and for long‑running services JIT modes with tuning provide comparable throughput while minimizing build time.
Flutter is Google's cross‑platform UI toolkit that uses the Dart language to build native‑compiled applications for iOS and Android, featuring its own rendering engine, widget hierarchy, hot reload, AOT/JIT compilation, networking libraries, state management, and best‑practice development guidelines.
To meet Xianyu’s rapid UI change demands and curb its swelling Android package, the team built a Flutter‑specific dynamic template system that compiles Dart widget code into JSON, streams it to the client, reconstructs the widget tree at runtime, and maintains 55‑60 fps performance while planning further widget support and caching.
This article details NetEase News' practical experience of gradually integrating Flutter as a module into an existing Android/iOS codebase, covering architecture, integration methods, build modes, project management, native‑Dart communication, routing strategies, debugging, encountered issues, and stability measures.
The article examines Flutter’s limited built-in JSON handling, explains why the popular json_serializable package can fall short for complex, generic objects, and introduces fish-serializable—a custom library with a ValueHolder, FishSerializable interface, JsonSerializer, and IntelliJ plugin—already used in production at Alibaba’s Xianyu and soon to be open-sourced.
This article examines the drawbacks of maintaining separate native codebases for iOS and Android, reviews the evolution of cross‑platform solutions such as WebView‑based frameworks, React Native, and Flutter, and shares practical insights, code examples, and future plans for using Flutter in large‑scale mobile projects.
This article explains how to replace cumbersome if‑else or manual map‑based routing in Flutter with a lightweight, annotation‑driven solution that automatically generates a page‑to‑URL mapping at compile time, using Dart's source_gen, build, and analyser packages.
Xianyu tackled Flutter adoption by creating a private CocoaPods CI pipeline, a component‑based fishRedux architecture, and a shared‑GL engine modification that let native middleware run in Flutter, thereby unifying Android, iOS, and Flutter development, improving build speed, and contributing tools back to the community.
This article explains how the Flutter team adapted Flutter's multi‑layer architecture to run on the Web, describing the three prototype approaches, the rendering, layout and painting strategies, CSS Paint API experiments, embedding considerations, portability limits, and the current implementation status.
This article provides a step‑by‑step tutorial for beginners who want to learn Flutter, covering prerequisites, a quick Dart introduction, installing and running a Hello World app, experimenting with core widgets, UI challenges, personal tips, and a curated list of further learning resources.
The Xianyu team tackled iOS Flutter app bloat by analyzing App.framework, cutting excessive type‑casting, applying dwarf‑stack‑trace and obfuscation flags, stripping dSYM symbols, and removing duplicate assets, which together shrank the generated framework by over 30 % and improved download efficiency.
At QCon2018 Shanghai, Alibaba’s Xianyu team unveiled a three‑platform development model that uses Flutter for UI and Dart for both client and a lightweight “glue‑layer” server, cutting product‑page implementation time from eight months to 1.5 months while delivering near‑native performance and Java‑comparable backend metrics, and promising unified language, faster iteration, and future AI‑driven UI generation.
Flutter’s sub‑second hot‑reload works by scanning changed Dart files, generating incremental kernel (.dill) files, sending them to the running Dart VM via RPC, triggering the VM’s reload routine, and finally invoking the framework’s reassemble sequence to rebuild the widget tree, all enabled by JIT compilation during development.
The article explains how excessive memory use in a Flutter app, caused by ImageCache and related image handling, was diagnosed with Xcode Instruments and Dart Observatory, then mitigated through refined caching policies, adaptive screenshot resolution, improved FlutterViewController lifecycle management, and targeted garbage‑collection techniques, resulting in lower memory peaks and greater stability.
Flutter, a cross‑platform framework built on immutable, declarative widgets, lets beginners create UI using basic widgets like Text and Image, layout containers such as Row, Column, Stack, and Flex, manage visibility, and handle state through StatefulWidget lifecycle methods while observing app‑level lifecycle events.
This article explains Flutter's layered architecture, its high‑performance UI rendering pipeline, Dart language optimizations, typical development patterns, plugin and package management, common pitfalls such as lack of reflection and JSON handling, and provides practical code examples for mobile developers.
Flutter, Google’s open‑source cross‑platform UI framework built on Dart and Skia, provides native‑level performance through a layered widget‑rendering architecture, supports rapid development via hot‑reload (with known limits), offers extensive plugins, can be integrated into Android apps as an AAR, and delivers comparable frame‑rate performance to native code with a modest APK size increase.
This article provides a comprehensive analysis of Flutter's Image widget, especially Image.network, detailing its constructors, underlying classes, state management, image loading, caching mechanisms, and source code flow, while illustrating how images are fetched, decoded, and rendered in Flutter applications.
The article explains how Flutter adopts a React‑style reactive architecture—using immutable widgets, InheritedWidget for communication, Dart Streams and a Redux‑like store with reducers and interrupters—to achieve clear model‑view separation, fine‑grained UI updates, componentized multi‑store widgets, and shares Xianyu’s practical implementation details and code examples.
This article provides a comprehensive overview of Flutter, Google's cross‑platform mobile UI toolkit, covering its purpose, development history, key advantages, sample Dart code for state management and platform channel usage, and resources for quickly getting started with Flutter development.
This article explores Flutter's memory management, detailing the Dart runtime's generational GC, comparing Image widget memory usage across Android versions, and evaluating the impact of reusing or not reusing FlutterView on Java and native memory consumption, with practical test results and optimization tips.
This article provides an in‑depth technical overview of Flutter, covering its Dart‑based architecture, layered widget system, event handling, animation, navigation, plugin ecosystem, performance and APK size comparisons with WebView‑based frameworks, React Native, and native Android/iOS development.
The article examines Flutter’s memory architecture, compares its Image widget’s graphics‑memory usage to Android ImageView’s Java and native heap behavior across OS versions, and evaluates FlutterView integration strategies—showing reuse saves native memory and offering a pre‑render trick to reduce first‑frame latency.
Google announced at I/O that its Dart language will soon run on App Engine via managed VMs and custom runtimes, while also supporting Docker deployment, async/await features, and broader Chrome integration, aiming to make Dart a general‑purpose, front‑end and back‑end language with strong tooling and industry adoption.
