Author | Harper ZhuoInterview | Eric WangEditor | Monica HeProduced | GOSIM

Kevin Moore, Product Manager for Dart and Flutter at Google, considers himself an engineer first and foremost, even after 11 years at Google. His expertise lies in web technologies, particularly in developing compilers for JavaScript and WebAssembly.

Kevin Moore has played a pivotal role in advancing Dart’s adoption for production-level WebAssembly applications. With his deep technical insight and forward-thinking vision, he spearheaded the release of Dart 3.3, which introduced a new JavaScript interoperability model, significantly enhancing the Dart developer toolkit.

Beyond his technical acumen, Kevin Moore is also a strategic thinker. He successfully integrated Dart with Google's AI services, launching the AI Dart SDK, which enables developers to seamlessly integrate generative AI capabilities into Dart and Flutter applications.

At GOSIM CHINA 2024, Kevin Moore delivered a compelling talk titled "Flutter: Google's Ul toolkit for Mobile, Web, & Desktop Apps from a Single Codebase" Following the event, GOSIM Open AGI Forum hosted an exclusive interview between Kevin Moore and CSDN senior tech editor Eric Wang, where Kevin shared his insights on Flutter’s evolution and his journey as a product manager.

Highlights of the Conversation:

• Product management isn’t about managing people—it’s about managing the product. My responsibility is to develop strategies and oversee feature rollouts.
• The key challenge in developing Flutter and Dart is creating a better web application model—one that enables shared applications to run seamlessly across platforms. Improving web programming experiences while enhancing interactivity is a central focus.
• One of Flutter’s most impressive features is hot reload. It’s a game-changer for developers, allowing them to edit code and see updates instantly—without waiting 10 seconds, a minute, or even longer for a full rebuild.
• Cross-platform support is a tough challenge, but our team is dedicated to providing an exceptional developer experience. We ensure fast app loading times, hot reload capabilities, and top-tier performance.
• I'm particularly excited about WebAssembly. It has already made a massive impact in browsers, and its potential is immense.
• The Flutter and Dart communities are among our greatest assets. They are welcoming, passionate, and engaged. I encourage developers to participate in meetups or online discussions.
• Beginners often spend too much time watching tutorials. Learning only through passive consumption—like listening to a language without practicing—will lead to slow progress. You need to start building projects.
• We prioritize maintaining near-native performance. Compared to native development kits for Android and iOS, we focus on cross-platform compatibility while preserving high-performance standards.

1.From Experimentation to Breakthrough: The Evolution of Dart to Flutter

Eric Wang: What was your first programming language, and how did you become a programmer?

Kevin Moore: My first programming language was BASIC, specifically GWBASIC, which came bundled with MS-DOS, probably around DOS 4 or DOS 5. I was fortunate to land a job in high school, around 9th grade, at a company where I worked with Microsoft’s Active Server Pages (VBScript). That marked the beginning of my career in Microsoft, where I spent many years working with BASIC. In college, I studied C, C++, and Java. Eventually, I developed a strong interest in C# and thoroughly enjoyed working with it, which essentially defines the trajectory of my career.

Eric Wang: What was the initial goal when you started developing Flutter?

Kevin Moore: I joined Google around 2013, in the Chrome department, which had many teams focused on efficient and interesting experiments, some of which evolved into HTTP/2 and HTTP/3. They were working on a series of developments around Chrome, mostly converting apps to PWAs (Progressive Web Apps), and researching the Native Client project, which evolved into asm.js. That technology eventually became WebAssembly.

Dart and Flutter were both independent experimental projects. The initial vision was: Can we do better than JavaScript? Later, the question evolved: Can we go beyond the DOM? Can we create an API that’s cleaner, more maintainable, and better than the DOM? It turns out, neither Dart nor Flutter were ever integrated into browser standards, but after developing for a while, they eventually merged.

To revisit the original vision for Flutter and Dart, the focus was on how to build a better web application model—a shared app model that works across platforms. How could we improve the web programming experience and use this platform to enhance interactive network experiences? In many ways, we’re still working toward that vision. It all began with a mobile-first approach, and interestingly, everything fit perfectly into a complete system.

Eric Wang: You mentioned you’ve been at Google for 11 years. Before working on Flutter, what role did you have within the Google team?

Kevin Moore: When I first joined Google, I was on the Dart team as a Dart development expert, and Dart was still in its very early stages.

Back in the early 2000s, I worked at Microsoft and developed a UI toolkit—WPF, or Windows Presentation Foundation. Some people may have heard of XAML, an XML-based layout tool. It’s funny to think about now, but 20 years ago, before JSON, XML ruled everything.

When I transitioned from Windows-centric technologies to web technologies, I became excited by openness—open standards, web collaboration, and open-source. This was a stark contrast to Microsoft’s stance 20 years ago, though I’ll note that Microsoft has since made great strides in open-source participation.

I wanted a language that was more like C#, as I spent a lot of time working with .NET and Microsoft technologies, but I hoped it could be applied to web development. That’s when I came across Dart, and it turned out to be exactly what I was looking for. Interestingly, Microsoft launched TypeScript, which is similar to Dart, but in some ways, Dart's implementation felt more reasonable.

I appreciate the robustness that Dart achieved in its language design. It has a very strict safety mechanism while still supporting web development, meaning it can be compiled into JavaScript. Dart also allows for optimization of native code, making it a perfect fit for WebAssembly, and it performs exceptionally well in JavaScript environments.

Eric Wang: Can you talk about the importance of Dart in Flutter’s success? What unique aspects of Dart enhance Flutter's capabilities?

Kevin Moore: There is a very strong synergy between Dart and Flutter. A key feature in Flutter is using Dart to define widgets, and to simplify Flutter’s development process, the team made several improvements to Dart. For example, we removed certain new keywords to streamline the syntax and spent a lot of time improving the inline definition and expression handling of collections.

Dart has introduced a variety of features, such as the switch expression and generalized pattern matching, which have significantly enhanced Flutter’s development efficiency. We are in a highly iterative development cycle, dedicating significant time to improving Dart, especially methods that enhance the developer experience for Flutter developers.

2.Hot Reload is the Most Popular Feature, but Cross-Platform Support is Challenging

Eric Wang: What specific issues were you trying to solve with Flutter's GPU?

Kevin Moore: I mainly worked with the web team, and initially, there was a Skia-based renderer. Chrome uses the Skia engine everywhere it runs. It's very portable and can work across platforms like Android, desktop, Linux, etc.

Our initial goal was to solve performance issues and eliminate stuttering. To achieve smooth fonts, curves, and shadows, the team began using shaders and leveraging GPU acceleration for rendering. It turned out that these technologies were very effective for smooth edges, rasterized fonts, achieving blur effects, and other processes. The goal of the Impeller project was to see if we could pre-compile shaders and handle them more intelligently, leading to faster start-up times and preventing stuttering. We realized that by rewriting the entire graphics stack, we could take full advantage of GPU capabilities.

In the August release, we previewed the possibility of exploring 3D effects in Flutter. My web team was dedicated to ensuring it could run in offline areas. It supports Android, iOS, Mac, Windows, and Linux. We called it “Brandon,” and it released a package, which we referred to as 3D or Flutter scenes. The ability to animate and create in 3D is incredibly exciting, and this is where I hoped Flutter could take us. To move from a 2D-centric framework into 3D is definitely thrilling—challenging but very fun!

Eric Wang: What was the biggest technical challenge you faced during Flutter's development, and how did you overcome it?

Kevin Moore: We did a pretty good job at meeting our goals. But a major challenge with Flutter is making cross-platform support a reality. It’s definitely a tough problem to solve, so the team has focused on providing an excellent development experience. Developers need to quickly load applications, implement hot reload, and maintain great performance.

When trying to tackle multiple tasks at once and pursuing several goals, it complicates things. That’s why we use two separate JavaScript compilers on the web. One is aimed at fast compilation for iterative development, while the other analyzes globally and generates highly efficient JavaScript code. It’s a more complex problem, and it requires a focused effort to ensure it runs smoothly, so developers can stay productive during the build process and deliver high-performance end-user applications.

Eric Wang: What is the Flutter feature you're most proud of, and why? What were the key considerations behind it?

Kevin Moore: Flutter has a lot of cool features, but the one I’m most proud of is hot reload. It’s such a popular feature, and it’s something that people are trying to implement in other projects, like Rust's compiler and others.

For developers, the ability to edit an app while it's running and immediately see the changes without having to wait to reload or rerun the application is incredibly complex. This works across platforms like desktop, iOS, and Android. What we have today in terms of runtime environment and language design makes this a challenging task. In fact, the team is actively working on bringing this functionality to the web as well, which sets Flutter apart as a key differentiator.

Eric Wang: Is hot reload the feature that most influences the overall development experience? What other features have a profound impact on the development experience?

Kevin Moore: Hot reload is absolutely crucial to the development experience. The ability to directly edit code without having to wait for 10 seconds, a minute, or even two minutes for rebuilds is a game changer. Just being able to iterate quickly is amazing!

Beyond that, Flutter excels in cross-platform consistency. Whether you're deploying a web app, Android, or iOS, they look pixel-perfect. Widgets might render slightly differently depending on the platform, but they are almost identical on all platforms. Flutter delivers near-perfect pixel consistency while maintaining high levels of stability and performance, offering an excellent developer experience. This is truly one of Flutter's unique and valuable advantages.

Eric Wang: How does Flutter distinguish itself from other frameworks on the market? What strategies have you used to maintain its leadership position?

Kevin Moore: Our advantage is that we strive to maintain performance similar to native apps as much as possible. Compared to native toolkits like those for Android and iOS, we prioritize cross-platform compatibility. Interestingly, when considering functions like camera, microphone, video, accessing contacts, or location information, users have the same experience whether it's on native devices or the web.

Our efforts with the Impeller project have driven significant performance improvements, particularly for WebAssembly, pushing web performance closer to native app levels, which is a major breakthrough. We’ve also invested heavily in GPU and 3D capabilities to ensure that we fully utilize the features of the devices.

Our competitive edge is also fueled by continuous investment in programming languages. We're advancing macro function support, with plans to release it in 2025, and the team is constantly working to improve performance and user experience for 3D capabilities.

3.Native Apps vs. Flutter Apps: "We Reject the Binary Choice!"

Eric Wang: How does the team handle user feedback? Could you share an example of how user input significantly influenced the project direction?

Kevin Moore: We take user feedback very seriously and try to stay engaged. All of our code is hosted on GitHub, where we track issues. We also actively participate on platforms like Discord, Reddit, and other social media. We have several forums with highly active users who can provide direct feedback. There are numerous examples of this.

Recently, we introduced a feature in Dart based on user feedback: users wanted to pass parameters via super.x without needing to pass them to the superclass again, to reduce errors and improve code readability. We accepted this suggestion and implemented it quickly. Now everyone benefits from that feedback.

Additionally, Flutter’s open-source nature means that many users actively contribute by fixing their own bugs, which has resulted in numerous community contributions. It’s been fantastic.

Eric Wang: Some Flutter app users prefer a native app experience rather than a Flutter one. How do you balance this?

Kevin Moore: Our greatest effort is to avoid the false dichotomy of "you must choose one or the other." The team is committed to balancing both. We can provide an excellent developer experience and build a high-performance environment without compromising either. There’s no reason why we can’t support both: offering great developer experience while also enabling cross-platform support.

Native toolkits have many advantages. But for most user interactions and app experiences, most of the code is shared. Rewriting an entire project from scratch, like moving from Android to iOS, is inefficient in many ways. Therefore, the team aims to offer an exceptional development experience, true high performance, and code sharing. Users shouldn’t be forced to choose between the two.

Eric Wang: How do you decide the release schedule? Which features do you prioritize first?

Kevin Moore: We now rely heavily on data-driven decisions. Looking at past release patterns, we follow a stable schedule. We typically don’t announce specific release dates in advance, but we maintain a steady pattern. This approach makes many things manageable, especially during holidays and Google’s annual spring events.

An important fact to know is that the main branches of Dart and Flutter are always stable. For internal apps at Google, such as Google Earth, Google Classroom, and Family Link, we don’t use the stable version; we use the development version. These versions have been in use and tested internally for weeks before release. This means they’ve gone through tens of thousands of internal tests across Google’s apps, ensuring very high quality.

Stable releases focus mainly on API stability. We aim to minimize changes to the API. If you’re using a beta or development version of Flutter or Dart, the API may change between updates. However, once the stable version is locked, the API stays stable for a period. This allows us to consistently maintain high release quality. Typically, we maintain API stability for about three months to ensure releases don’t negatively impact the user experience.

Regarding release dates, the team has a well-established process to handle experimental features and other items, enabling us to move quickly while maintaining high stability and ensuring regular releases.

4.WebAssembly's Potential and the Future of Flutter

Eric Wang: Looking ahead, which trends in the tech industry do you think will have the biggest impact on Flutter’s development?

Kevin Moore: I’m very interested in WebAssembly. I believe it’s already a huge force in the browser and will only grow. For instance, the 3D maps you see on Google Earth are driven by C++-powered WebAssembly.

The impact of WebAssembly will extend beyond the browser into the server space. Many companies are working on implementing WebAssembly beyond the browser, and the Dart team is closely monitoring this development. Personally, I’m excited about it.

The resurgence of embedded programming is also fascinating. Technologies like RISC-V, which offer fully open and scalable architectures with lower implementation costs, are especially intriguing. In the summer of 2024, LG’s WebOS will be the first major platform to support Flutter. This will be the primary development focus for Flutter on WebOS, and it’s exciting to see this in the embedded space. Additionally, Toyota is running Flutter on its in-car infotainment systems.

Seeing Flutter run on so many different types of devices is really exciting. This aligns with our initial vision — to develop applications for different types of devices without needing to rewrite the entire app from scratch. Sharing code is great. While applications may not be perfectly identical across all platforms, being able to reuse the majority of the code for a wide range of devices is a major advantage. I believe Flutter is fully capable of leveraging these opportunities.

Eric Wang: What possibilities do you see for Dart integrating with AI in the future?

Kevin Moore: Google has made significant investments in AI. We have many APIs that can run on devices, whether on Chrome, Android, or in the cloud, and we have great interfaces with all of these.

Most AI solutions rely on HTTP and JSON for API calls. You just need to make a request via an API to call powerful language models, and the AI works in the background. For Flutter, when interacting with AI, the focus is on rendering pixels and presenting the UI — whether it’s images or video, the AI processing is largely transparent to Flutter.

As developers, we can benefit a lot from this, whether it’s by viewing error reports, crash reports, or analytics data, or helping write code. We’re still exploring more universal services that are incredibly useful for programmers.

Eric Wang: How is the Flutter team preparing for these trends? What actions have you taken?

**Kevin Moore: **The team is currently pushing for device-side AI applications, using large language models (LLMs) on edge devices. Google has already begun integrating Gemini Nano into devices. This trend is growing, and Flutter developers will need to think about how to integrate Flutter apps with AI models on devices.

Flutter has many unique features, some of which haven’t been made public yet. The main thing developers need to consider, regardless of whether they’re using TypeScript, Kotlin, Rust, Dart, or other languages, is the ability to efficiently access device services.

Chrome is working to run LLMs in the browser environment, and Android is pushing various features on mobile devices. We will fully integrate with these services to enable communication with backend services and device services.

Eric Wang: Flutter currently supports multiple platforms and devices. Do you have plans to support more hardware devices or operating systems, such as smartwatches or in-car entertainment systems?

Kevin Moore: Flutter can already run on Android devices like the Pixel Watch. I haven’t tried it myself, but the team is working hard to improve in this area.

Adding WebAssembly is an interesting direction, as we see the web as a platform target. However, if there are two separate compilation targets, JavaScript and WebAssembly, it could lead to some redundancy.

Toyota is working on automotive-related technologies. Other teams are also focusing on embedded work. We hope developers won’t have to maintain a separate branch of Flutter for custom platforms. The team management is aware of this issue, and our goal is to make it easier.

5.The Role of a Product Manager at Google and Advice for Flutter Beginners

Eric Wang: As a product manager, can you share an experience where you had to adjust your strategy when facing challenges? Have you ever reflected on your leadership style when the team faced difficulties?

Kevin Moore: As a product manager at Google, I’ve always considered myself an engineer. I love programming. Perhaps I should spend less time coding and more time handling documentation and emails, which is more in line with a product manager’s role.

When you're working as an engineer, you face challenges like code complexity, feature creep, stability, and the richness of functionality, and you have to make choices between these trade-offs.

As a product manager, you face more macro-level decisions. For example, do we focus on developing a series of small features and fixing minor bugs, or should we concentrate on addressing major bugs or investing more in new technologies? A typical example is the addition of a new compiler toolchain for Dart and Flutter to support WebAssembly. This was a hefty task. Now, we are thinking about how to optimize existing technologies to avoid too much technical debt and ensure that quality doesn't drop as we add new features.

Factors like scheduling, external customer demands, and early adopter feedback on new technologies all need to be considered. These challenges are very interesting. I enjoy interacting with customers and seeing their excitement about technologies like WebAssembly. This is truly a shift from a programmer's role to a management role.

Eric Wang: In China, there's a saying that when a programmer turns 35, they need to decide whether to continue coding or transition into management. What do you think about this? If you were in this situation, how would you approach it?

Kevin Moore: As a product manager, I don't manage people directly; I manage the product itself. My responsibilities are more about strategy, ensuring the overall release of features, and managing the product's delivery.

The team has exceptional engineers who are focused on compiler development. My role is to handle scheduling, how we release features, and how we communicate technical changes to users. I also have to make sure the performance improvements are worthwhile. As a product manager, my job is to translate technical challenges into actionable strategic plans. This requires coordinating various opinions through communication with engineers and partner teams to ensure smooth product progress.

Eric Wang: For those who are just starting with Flutter and Dart, what advice would you give? Are there any educational resources you would recommend?

Kevin Moore: Welcome aboard! One of the most valuable assets of Flutter and Dart is our community—it's incredibly friendly and enthusiastic. Whether it’s Reddit, Discord, or other social platforms, or even local Google groups, there are many community events for Flutter. I recommend participating in community meetups or engaging with others online.

As a beginner, my advice is to build something real but simple. For example, create a simple game. Many beginners aim to create a new social platform or work on a large project, but I recommend starting with simple projects and gradually building experience. Personally, I enjoy building small games because their rules are straightforward. So, start with small projects and actively engage with the community.

Eric Wang: What are some common mistakes beginners make, and do you have any advice on how to avoid them?

Kevin Moore: I think the most important thing is to start building real, usable projects as soon as possible. It’s easy to spend a lot of time watching video tutorials, but if you just watch and learn without doing, it’s like learning Chinese by only listening to recordings—progress will be slow. You need to take action and start building. The sooner you decide on a project and start working on something that excites you, the better. You may face obstacles, but you’ll find people who are willing to help, and that's the beauty of the community. The sooner you get started, the sooner you’ll encounter and solve problems, which is extremely helpful for learning.

Eric Wang: That concludes all the questions. Thank you, Kevin Moore, for the insightful discussion. Thank you to all the developers watching. See you next time!