This 1st in-person event will include several tech communities from the East African Region and continental members. Participants will have an excellent chance to learn about Android development and opportunities and to network with Mobile experts in the ecosystem.

Conferencing

The largest flutter-focused developer conference in Africa

flutterconKe

Room A

Room B

flutterconke24

Open source projects drive innovation and collaboration, but creating and maintaining a successful project involves more than just writing code. This talk explores the key steps to launching an open source project, from the initial idea to building a thriving community. We will discuss:
- Designing apps with open source principles in mind
- Setting up open source projects on GitHub
- Managing contributions and community engagement
- Strategies for long-term maintenance of open source projects

Brayan Kai Mwanyumba

OSCA Nairobi Community: Creating and Maintaining Open Source Projects

Lunch Break

A big hurdle that mobile developers have to contend with is developing an app when the backend is not yet ready. Often developers resort to using sample objects and then have to rewrite their code again once the api is set up. But what if we started consuming the api immediately without waiting for the backend to be set up? This is where mocking servers comes in.
In this session we will dive into the details of mocking servers and how it can be leveraged to accelerate development of mobile applications. In addition we will also look into the OpenApi spec formerly known as Swagger which helps us document rest apis in a manner that allows both the generation of the mock server as well as outlining the structure of the api. The OpenApi document can then be used by the backend developers to create an api compliant with the document. Additionally, we will also go through how to mock servers without an OpenApi document for even faster prototyping. By the end of this session, you'll have a solid understanding of how OpenAPI can help you document your APIs and how mock servers can serve as an essential tool for speeding up development and reducing the time-to-market for your products.

James Kaguru

Gophers Community: Mock It 'Till You Make It: Accelerating Development with OpenAPI and Mock Servers

This workshop introduces the participants to pigeon, a flutter code-gen tool, which can be used to make typesafe ffi calls from the native platforms to flutter. I'll guide the participants from defining the APIs to returning typed errors and exceptions on a case-by-case basis to integrating them into their projects. This workshop would promote the need for plugin users to catch all platform exceptions when integrating plugins since they are cumbersome and lack much-needed context.

Sebastine Odeh

Building robust plugins with pigeon

Topic?Title:
Crafting Reusable Flutter App Templates for Streamlined Development

Description:
Creating and maintaining high-quality apps requires efficient development practices and a unified approach within teams. In this talk, I will explore how reusable app templates can revolutionise how Flutter development teams work, ensuring consistency, ease of onboarding, and rapid project initiation. We'll dive into the problem of starting new projects from scratch and how it can be a tiresome and time-consuming process. To address this, we'll explore the advantages of reusable templates, such as maintaining uniform code standards, facilitating new team member onboarding, and providing a base architecture with a single command.

Solution:
I will introduce BrickHub(https://brickhub.dev/), a platform built on top of Mason Package (https://pub.dev/packages/mason), which provides a collection of tools that allow developers to create, discover, and use reusable templates (bricks). These bricks make it easy to start new projects or enhance existing ones without the hassle of setting up the base structure from scratch. By leveraging BrickHub and Mason, development teams can streamline their workflow and boost productivity.

Key Takeaways:
1. Uniform Code Standards: Learn how reusable templates ensure consistent architecture and coding practices across your team, making it easier to maintain and review code.
2. Efficient Onboarding: Discover how templates can help new team members quickly understand and adopt the architecture and coding standards followed by your organization.
3. Rapid Project Initiation: Understand how reusable templates can save time and effort when starting new projects, allowing developers to focus on building features rather than setting up the base structure.
4. Streamlined Project Setup: Explore the capabilities of BrickHub and Mason, and how they enable the creation, discovery, and utilization of reusable templates called bricks.

Experience Level with the Topic:
I have an expert-level understanding of this topic, with extensive experience in using bricks for various real-world personal and client Flutter projects that serve tens of thousands of users. My notable projects include Calcut and Cupertino Icons Gallery (https://github.com/capps096github/cupertino_icons_gallery), which have benefited significantly from the use of reusable templates. Furthermore, I have also published my own open-source template,(https://github.com/capps096github/Cephas-Bricks/tree/master), which I regularly use to streamline and standardize my Flutter app development process. My practical application of these templates in large-scale, user-centric projects has given me a deep, hands-on understanding of their advantages and best practices.


Have I Given This Talk Before?
This will be the first time I am presenting this specific talk on creating reusable app templates for Flutter teams. However, I have a proven track record of impactful contributions to the developer community. My overall contributions have positively impacted over 10,000 developers, and my answers on StackOverflow have reached approximately 3,000 views. I have delivered 5 event sessions with a combined attendance of 580+ participants and conducted 2 Flutter training sessions for 120+ learners. Additionally, my open-source project has been used by over 8,000 users and has garnered more than 20 GitHub stars. This talk will include fresh insights into the practical use of bricks for real-world Flutter projects, highlighting new techniques and best practices that I have developed and refined through my extensive experience.


Keywords:
Flutter, App Templates, BrickHub, Mason, Cross-Platform Development, Code Standards, Onboarding, Project Initiation, Development Efficiency, Streamlined Workflow.


Mugisa Brian (Cephas)

Crafting Reusable Flutter App Templates for Streamlined Development

Transition

We often overlook the subtle nuances that can transform a good app into a truly exceptional one. This talk dives deep into the world of micro-interactions and UI design principles to elevate your Flutter app's user experience. From the tactile sensation of a button press to the graceful transition between screens, we'll explore how to create intuitive and enjoyable user flows. Learn practical techniques to incorporate haptics, animations, typography, and colour psychology to build apps that function and delight users. By the end of this session, you'll have a toolkit of strategies to create Flutter apps that leave a lasting impression.


Mariam Hamzat

Microinteractions Matter: Designing for Seamless User Flows

Lunch

The programming landscape is evolving, and with it comes an innovative feature that promises to revolutionise how we write and generate code: macros. Currently in an experimental phase, macros offer a tantalising glimpse into a future where development processes are more streamlined, boilerplate code is minimised, and productivity is maximised.

In this session, we will delve into the world of macros, providing a comprehensive understanding of their potential and current capabilities. We will address the experimental nature of macros, discuss their future impact, and explore practical applications that can benefit developers today.

Key points covered in this talk:
1) What Are Macros?: An introduction to macros, explaining their purpose, how they work, and why they represent a significant advancement in code generation.
2) State of Macros: Understanding the experimental status of macros, including the latest updates and what "subject to change" means for developers.
3) Practical Applications: Real-world examples demonstrating how macros can simplify coding tasks such as JSON serialisation, creating immutable data classes, and reducing repetitive code.
4) Getting Started: A step-by-step guide on how to enable and start experimenting with macros in your projects, highlighting best practices and common pitfalls.
5) Future Prospects: Insights into the future of macros based on feedback from the developer community and ongoing development efforts.

By the end of this session, attendees will have a solid understanding of what macros are, how to responsibly experiment with them, and how to prepare for their potential integration into mainstream development workflows. This talk is perfect for developers eager to stay ahead of the curve and leverage cutting-edge features to enhance their coding efficiency.

Grace Youpele

Understanding Macros: Exploring the Future of Code Generation

The presentation will dive deep into the world of CustomScrollView and slivers in Flutter, demonstrating how these tools can be used to create advanced and highly performant scrolling experiences in mobile applications.

Key Topics
Introduction to CustomScrollView:

Definition and Usage: Understand what CustomScrollView is and when it's appropriate to use it compared to other scrollable widgets like ListView and SingleChildScrollView.
Basic Setup: Learn how to set up a CustomScrollView and incorporate it into your Flutter application.
Understanding Slivers:

What are Slivers?: An overview of slivers and their role in Flutter's scrollable widget system.
Types of Slivers: Introduction to various slivers such as SliverList, SliverGrid, SliverToBoxAdapter, etc.
Building a CustomScrollView:

Combining Slivers: How to combine multiple slivers to create complex, custom scrollable layouts.
Practical Examples: Step-by-step examples to illustrate the creation of a CustomScrollView with different slivers.
Using SliverAppBar for Collapsible Headers:

Collapsible Headers: Implementing a SliverAppBar that collapses and expands as you scroll.
Customization: Customizing the appearance and behavior of the SliverAppBar for a more polished user experience.
Creating SliverPersistentHeader for Sticky Headers:

Sticky Headers: How to use SliverPersistentHeader to create headers that remain visible while scrolling.
Behavior Customization: Techniques for customizing sticky headers' behavior and appearance.
Implementing SliverList and SliverGrid:

Efficient Lists and Grids: Using SliverList and SliverGrid to create efficient, scrollable lists and grids.
Lazy Loading: Implementing lazy loading to optimize performance.
Using SliverFillRemaining and SliverFillViewport:

Flexible Layouts: How to use SliverFillRemaining and SliverFillViewport to create flexible, adaptive layouts.
Advanced CustomScrollView Techniques:

Custom Scroll Effects: Combining slivers with custom scroll effects for unique user interfaces.
Nested CustomScrollViews: Implementing nested CustomScrollView for complex scroll interactions within your app.
Performance Considerations:

Optimization Best Practices: Best practices for optimizing performance when using CustomScrollView and slivers.
Debugging and Profiling: Techniques for debugging and profiling scroll performance to ensure smooth and responsive user experiences.
Real-world Examples and Use Cases:

Demonstrations: Presenting practical use cases and examples from real-world applications to show how CustomScrollView and slivers can be effectively used.
Conclusion
By the end of the presentation, attendees will have a thorough understanding of CustomScrollView and slivers, equipped with the knowledge to create advanced, performant, and visually engaging scrollable experiences in their Flutter applications. This session aims to enhance the developer’s ability to leverage Flutter’s powerful scrolling capabilities for building sophisticated and user-friendly interfaces.

Gidudu Muyobo Nicholas

Mbuga Enoch

Mastering CustomScrollView and Slivers in Flutter for Advanced Scrolling Experiences.

Welcome to a session on streamlining Flutter app development by mastering the management of different developer environments such as dev, test, and prod. Say goodbye to the risky manual oversight of code deployments that could lead to breaking things. Join me in this session as I simplify the process for you.

Siro Daves

Multiple Environments in your Flutter App

Here's the updated description with the additional points you requested:

Discover how Android development can be a powerful tool for social change. This talk explores the intersection of mobile technology and community service, offering practical insights on creating impactful apps for non-profits and social initiatives.

In this session, we will:

1. Explore the potential of Android development for social change.

2. Learn to identify and address community needs through mobile apps.

3. Explore long-term benefits and career opportunities in tech for social impact.

4. Understand unique challenges in developing apps for non-profits.

5. Gain insights on creating impactful, accessible apps for diverse users.

6. Learn to measure and maximize the social impact of your Android projects.

7. Discuss sustainability strategies for social good app development.


Victor Turuthi

Mobile Apps for Social Good: Bridging Mobile Development and Community Service

Discover how Flutter can be used to transform the world of wearables. From smartwatches to fitness trackers, learn how to create seamless, responsive, and feature-rich apps that fit on your wrist. This session delves into the unique challenges and opportunities of developing for wearables with Flutter, providing insights and real-world examples to help you start building innovative applications for this rapidly evolving market.

Ahmed Hamdan

Flutter for Wearables: Building the Future on Your Wrist

Dart 3 introduced a game-changer: pattern matching. This powerful tool lets you write concise, elegant code that reads like poetry. Gone are the days of lengthy if-else chains and cumbersome data parsing. Pattern matching gives you the power to dissect data structures, extract values, and control flow with newfound clarity.

This talk will be your deep dive into the world of Dart 3 pattern matching. We'll explore:

The fundamentals: What is pattern matching, and how does it work?
Syntax magic: Demystifying the different patterns and their capabilities.
Power in practice: Witnessing pattern matching in action across various use cases:
Destructuring data structures (records, lists, maps)
Handling complex data shapes with ease
Writing elegant switch statements and control flow logic
Validating input and handling errors gracefully
Beyond the basics: Advanced techniques like guards
By the end of this talk, you'll be equipped to leverage the power of Dart 3 pattern matching and write cleaner, more expressive, and maintainable code. Get ready to unlock a new level of code mastery!

Ethiel Adiassa

Level Up Your Code: Demystifying Dart 3 Pattern Matching

WASM (WebAssembly) is a low-level binary format designed for high-performance execution in web browsers It offers near-native speed for computationally intensive tasks. When integrated with Flutter, WASM can be highly beneficial especially for web applications that require high computational performance. 

In this session, we will explore the potential of integrating WebAssembly with Flutter to boost app performance. This session will cover the fundamentals of WASM, including its benefits, capabilities and complexities.

By the end of the session, attendees will have a clear understanding of  WASM and how to leverage on it to achieve greater performance and efficiency in Flutter web apps, along with practical insights on managing and optimising this integration.

This session is ideal for developers looking for options to improve the  performance of their Flutter web applications and for the curious developers looking to understand the emerging technologies in the Flutter realm.

Jackie Moraa

WASM For Improved Flutter App Performance

In the competitive app development world, launching a Flutter application requires more than just writing code and hitting the "Ship" button. Before you launch, critical steps can make or break your app’s success. Join us for an insightful session on the ultimate pre-launch checklist for Flutter applications, where we’ll highlight the essential elements you need to consider to ensure a smooth and successful deployment.

This session is designed for developers who want to elevate their Flutter app development process by understanding and implementing best practices before going live. We'll dive into key areas including:

- Testing and Quality Assurance: Learn the importance of comprehensive testing to guarantee your app’s stability and performance.
- Environment Setup (Flavors): Discover how to effectively manage different environments for various stages of development.
- CI/CD Pipeline: Understand the advantages of continuous integration and deployment in maintaining your app’s integrity.
- Monitoring and Error Reporting (Crashlytics): See how proactive monitoring can help you identify and resolve issues quickly.
- User Tracking (Analytics): Gain valuable insights into user behavior to inform your development and marketing strategies.
- Security Best Practices: Learn how to protect your app and user data from potential threats.
- App Store Submission Guidelines: Navigate the complexities of app store compliance to ensure a smooth approval process.
- Performance and Accessibility: Enhance user satisfaction by optimizing your app’s performance and accessibility features.

By the end of this talk, you’ll have a comprehensive understanding of the crucial pre-launch considerations for your Flutter app’s success. This session focuses on raising awareness of these key aspects, empowering you to make informed decisions and confidently launch your app to the world.

Damilola Alimi

Jamiu Okanlawon

Ready to Launch? Essential Pre-Launch Steps for Flutter Applications

When building your product, have you ever wondered what is the most important place to focus your efforts on? Where to start in implementing your idea? What your idea will look like in real life? How many meetings and discussions would it take before you can be sure you have the right solution? This session will answer how to solve this questions and validate your idea in within 5 days.

Brian Mathia

5 day idea validation with design sprints

SSL Pinning secures the connection by ensuring an app only accepts the server's specific certificate. If the app's stored certificate doesn't match the server's, the connection is rejected, preventing unauthorized access.
When using HTTPS, the server provides a certificate to the app, which may accept any certificate, exposing it to man-in-the-middle (MITM) attacks. Hackers can exploit this to intercept connections and introduce malicious certificates, leading to data breaches and information leaks.
I this session we will Explore the topic of SSL Pinning on Flutter Apps by looking into a walkthrough , advantages and limitations of implementing such. 

Ben Salcie

Say No to MITM , A flutter way to SSL Pinning

In this session we will look at techniques we can use to optimize the performance of our flutter apps and mostly on low-level devices who have limited luxury of memory. Understanding these best practices will help us build apps that deliver great performance experience across all your users.
Many devs may use high-end devices to debug,build and test their flutter apps,which might not reflect fully the challenges that low-end devices encounter while running the same apps.In this session we will check on the practices to ensure that flutter apps are well optimized to give a smooth performance even on such devices

Julius Ndegwa

Victor Mutethia

Optimizing flutter apps for low-level devices

Description:
-----------------
Unlock Dart's full potential with an in-depth look at DartVM! This session uncovers the inner workings of the Dart Virtual Machine, the engine behind Dart's performance and versatility. Whether you're an experienced developer or just starting, understand how DartVM optimizes your code for mobile and web applications. Join us to master DartVM and elevate your coding skills!

Key Takeaways and Learning Points:
----------------------------------------------------
Understand DartVM Architecture: Examine the architecture of DartVM, highlighting its key components and their interactions to execute Dart code efficiently.
Compilation Techniques: Learn about just-in-time (JIT) and ahead-of-time (AOT) compilation techniques that enable fast development cycles and high-performance execution.
Garbage Collection: Discover the nuances of garbage collection in DartVM and how it ensures smooth memory management for your applications.
Practical Applications: Gain insights into how these concepts can empower you to write more efficient, robust, and scalable Dart applications.

Experience Level with the Topic:
----------------------------------------------
As a Google Developer Expert (GDE) for Flutter/Dart, I have extensive experience with Dart and DartVM. My real-world experience includes deploying Dart/Flutter applications at scale and contributing to the Flutter community through various channels, including workshops and open-source projects.

Previous Presentations:
-----------------------------------
This talk has not been given before in its current form. However, I have previously presented on related topics at other events and developer conferences. The feedback has been positive, with many attendees appreciating the in-depth technical content and practical insights.

Keywords:
---------------
Dart
Flutter
DartVM
JIT
AOT
Garbage Collection
Mobile Development
Web Development
Performance Optimization

Festus Olusegun

Decoding Dart: An In-Depth Look at DartVM

Dive into the world of secure banking app development with Flutter! Join me for insider insights, best practices, and essential tools. Learn to navigate regulatory challenges, implement top-notch security, and excel in crafting innovative banking experiences.

Charles Kagwi

Building Secure Banking Applications Using Flutter: An Insider's Guide

This session seeks to dive into the exciting world of Foreign Function Interfaces (FFI) and how it unlocks a lot of functionalities beyond Dart itself. The Audience at the end of the session will understand what FFI is and the possibilities it offer, know how to use it in it basic form and how to optimize performance and access device-specific hardware capabilities.

David Adegoke

Flying with FFI in flutter

Unit test is a way for developers to build robust and scalable software. Golden tests are one of the best tools to quickly spot regression in the code.
Keep in mind that a test is only as good as it replicates the real-life usage of the software.
But default Golden tests don't represent real-life devices.
Let's make them better by changing the window's physical size, and pixel ratio. Let's load images, fonts, and icons. We can even represent notches or an open keyboard! 

Matthieu Pernelle

How to make premium Golden tests

Normally api fails monitoring is overlooked in the frontend and so in this session, we'll explore how to effectively use analytics to drive the performance and user experience of Flutter apps, with a specific focus on tracking API calls and other critical events e.g app crashes. We’ll delve into strategies for monitoring API failures, understanding their impact on app performance, and using event tracking to gain deeper insights into user interactions. Attendees will learn how to integrate analytics tools (mixpanel and crashlytics for starters) in Flutter, interpret data to make informed decisions, and apply these insights using best practices from real-world example to optimize functionality and enhance user engagement/experience.


Keynotes:
1) Integrating Analytics in Flutter.
2) Monitoring API Failures.
3) Event Tracking for User Insights.
4) Case Studies and Real-World Examples.

Keywords:
Flutter, Analytics, API Tracking, Event Tracking, Mixpanel

Emmanuel Bonke

Leveraging Analytics to Optimize Flutter Apps: Monitor API Fails & App Crashes

We'll explore running Dart on the Server, talk briefly about compile options/targets for Dart especially AOT, JIT & Kernel snapshot.  We'll also highlight  current framework options and Database ORMs. And lastly, we will explore deployment for flutter & dart applications.

Chima Precious

Crossing the chasm, Dart on the Server.

In this talk, we will explore the exciting world of GraphQL and demonstrate how to effectively integrate it into your Flutter applications using the powerful Ferry library. 
We'll begin with an introduction to GraphQL concepts, highlighting key features and benefits that make it an attractive choice for modern app development. Then, we'll dive into a step-by-step guide on setting up and using Ferry in a Flutter app, covering essential topics such as schema design, queries, mutations, and handling subscriptions for real-time updates.

Attendees will learn:

- The core principles and advantages of GraphQL.
- How to set up and configure Ferry in a Flutter project.
- Best practices for designing GraphQL schemas and writing efficient queries and mutations.
- Techniques for managing state and handling real-time data with subscriptions.
- Practical tips and tricks to optimize the performance and maintainability of your GraphQL-powered Flutter apps.

Samwel Atati

GraphQL Integration in Flutter with Ferry: Unlocking the Power of Efficient Data Management

I’m diving into the nuts and bolts of developing an online multiplayer Kalooki game. This talk will give an insight into creating responsive layouts that adapt seamlessly between portrait and landscape modes, ensuring a fluid experience across devices. I’ll break down the use of Flutter’s draggables and ReorderableListView for intuitive gameplay interactions, and explain how Firebase isn’t just for storing data – it’s for streaming live game action to players with precision.

Take aways:
- Techniques for responsive design in Flutter, accommodating various screen sizes and orientations.
- Implementing interactive animations for a tactile feel.
- Leveraging native flutter widgets like ReorderableListView and Draggable  for managing dynamic game elements.
- Firebase’s role in real-time data streaming and storage.
- Handling race conditions and maintaining data integrity with Firebase transactions.
- And a peep into RenderObjects.

Sessions

06 Day 1

07 Day 2

08 Day 3

@ 12:00 pm | Room A

@ 12:40 pm | Room ARoom B

@ 1:20 pm | Room A

event info