Amanda Hinchman-Dominguez
Senior Software Engineer | Coding Kinetics | Book Author
Chicago, Illinois, United States
Actions
Amanda Hinchman-Dominguez is a Senior Software Engineer, tech author, and the creator of Coding Kinetics. She specializes in JVM internals, concurrency patterns, Kotlin Coroutines, and local AI performance monitoring. An active contributor to the tech community, Amanda has deep roots in organizing regional user groups, writing technical deep-dives, and contributing to open-source software. In her spare time, she practices hot yoga and enjoys outdoor activities.
Topics
The Android Lens: Applying Mobile Forensics to AI Performance
Modern LLMs like Ollama are technically ground-breaking but suffer from significant thermal and energy inefficiencies on resource-constrained hardware. This is often an overlooked cost of LLM's deterministic nature of token generation along with the heavy, unoptimized CPU operations within the underlying math engines.
High energy demand translates to high water usage and thermal dissipation needs. For many communities, this environmental footprint makes local AI inaccessible or unsustainable. To solve this, we must adopt a more "frugal" philosophy, the way Android development does.
This talk explores the forensics of loading Llama 3.2 (1B) onto a Raspberry Pi 4 to emulate resource constraint conditions. Through the lens of Android and Kotlin multiplatform development - molded and developed in its nature of resource-constrained hardware - we will audit Ollama's source code and profile how it performs in real time. We will move past the high-level Go wrappers and into the unforgiving C++ threading and memory management, identifying the leaks and bottlenecks leading AI to drown in thermal throttling and hallucinations.
Attendees will learn:
- How to apply mobile performance patterns (like scoped locking) to AI engines.
- How to monitor real-time hardware telemetry (thermal/RAM) against token generation speed.
- Why "frugal computing philosophy" is an ethical necessity for sustainable AI deployment needed to save our fresh water resources.
Memory Leaks & Performance Considerations: A Cookbook
Out in the wild, Android faces real-life challenges that affect performance and battery life. For example, not everyone has unlimited data in their mobile plans, or reliable connectivity. The reality is that Android apps must compete with one another for limited resources.
From the newly published O'Reilly book "Programming Android with Kotlin: Achieving Structured Concurrency with Coroutines", this talk examines a range of memory leaks in concurrency clashing lifecycles, network data format, and more.
Performance considerations allow you to examine concerns that may impact your application’s ability to scale. If you can use any of these strategies as “low-hanging fruit” in your code base, it’s well worth going for the biggest win with the smallest amount of effort.
Kotlin Coroutine Mechanisms: A Surprisingly Deep Rabbithole
Sometimes you think you know coroutines, and then after a while, you’re like, “Wait, do I really know coroutines?” Inspired by the O’Reilly book _Programming Android with Kotlin_ and the upcoming new Droidcon eBook _Mastering Kotlin Coroutines: From Basics to Advanced _, this talk strengthens everyday coroutine understanding through playful explorations.
You don't have to master coroutines to get started and be productive with coroutines. But when you walk out of this talk, you have deep understanding of coroutine mechanics and what tools can help you debug coroutine behavior.
You might be in the beginning stages of learning Kotlin. Or maybe you’ve been using coroutines for a while and want to brush up, or maybe you're a little burned from other talks. Either way, you'll be looking at coroutines a little differently by the end of this session!
Crash Course on the Kotlin Compiler
Whether you’re learning about writing compiler plugins, learning about the data structures/algorithms in real-life scenarios, or maybe just wondering why that little red squiggly shows up in your IntelliJ IDE, learning about the Kotlin compiler is your answer to all the above.
Let’s face it - learning about the Kotlin compiler is hard. Luckily, being able to look through various plugins can give insight to how the Kotlin compiler processes data at every phase, from human-readable Kotlin code to machine-readable bytecode. This session intends to expose Kotlin compiler functionality through reverse engineering compiler plugins and all the phases a plugin may intercept, giving us a conceptual, high-level overview what the the Kotlin compiler looks like.
The audience will hitch a ride with the source code fed through the phases of the Kotlin compiler to observe its transformations and optimizations frontend-to-backend: no better way to learn than going in deep!
Keep insisting!
There's a formal process for sending proposals for the Kotlin language, and it's called KEEP (Kotlin Evolution and Enhancement Process).
During this year we've been making good use of it from the Arrow maintainers team, since we've filed the KEEP-87, where we propose support for compile time validation and dependency resolution. But no fear! we'll not talk about FP here, just about the complete pipeline we went through to get it done. We've learned a lot during the process, and would love to share our experience.
In this talk, you'll learn:
- What's the KEEP and why it's important.
- Why and how to file a new proposal for the language.
- The importance of having initial feedback before tackling the issue. (We got it from people in the Kotlin compiler team).
- How the Kotlin repository is organized and where you should look at to implement your proposal.
- Which pieces of code we needed to modify and how to achieve our goal (error loggers, argument generators ...etc.)
- How to iterate over it once the initial draft is presented by getting in the JetBrains feedback loop.
- Helping to maintain and evolve the language as a community effort.
Memory Leaks & Performance Considerations: A Cookbook
Out in the wild, Android faces real-life challenges that affect performance and battery life. For example, not everyone has unlimited data in their mobile plans, or reliable connectivity. The reality is that Android apps must compete with one another for limited resources.
From the newly published O'Reilly book "Programming Android with Kotlin: Achieving Structured Concurrency with Coroutines", this talk examines a range of memory leaks in concurrency clashing lifecycles, network data format, and more.
Performance considerations allow you to examine concerns that may impact your application’s ability to scale. If you can use any of these strategies as “low-hanging fruit” in your code base, it’s well worth going for the biggest win with the smallest amount of effort.
A Hitchhiker's Guide to Compose Compiler: Composers, Compiler Plugins, and Snapshots
If you are an Android Developer, chances are you are pretty excited about Jetpack Compose! But how does it work? In this talk, we will take you along the journey of a Composable function, from being written, going through the unknown lands of the Kotlin and Compose compilers to being executed and displaying UI!
From Composables all the way down into the compiler plugins, we expose the metaprogramming responsible for all the "magic". Whether your interest is Jetpack Compose, compilers, or code transformations, this talk takes an otherwise complicated topic and makes it digestible for everybody by diving into specific features offered by Compose.
By examining Compose's snapshot system, you'll follow the compiler phases down to intercepting code transformations with IR. By recognizing the patterns that make it hard for Compose to generate efficient code, and this can help us to recognize patterns to use for performance.
A Hitchhiker's Guide to Compose Compiler: Composers, Compiler Plugins, and Snapshots
If you are an Android Developer, chances are you are pretty excited about Jetpack Compose! But how does it work? In this talk, we will take you along the journey of a Composable function, from being written, going through the unknown lands of the Kotlin and Compose compilers to being executed and displaying UI!
From Composables all the way down into the compiler plugins, we expose the metaprogramming responsible for all the "magic". Whether your interest is Jetpack Compose, compilers, or code transformations, this talk takes an otherwise complicated topic and makes it digestible for everybody by diving into specific features offered by Compose.
By examining Compose's snapshot system, you'll follow the compiler phases down to intercepting code transformations with IR. By recognizing the patterns that make it hard for Compose to generate efficient code, and this can help us to recognize patterns to use for performance.
A Brief History of Memory Leaks
Memory and threading in is some of the most difficult and complicated topics in Android. This talk introduces what memory leaks are, and why they’re so hard to find. Taken from excerpts of the newly published O'Reilly book "Programming Android with Kotlin: Achieving Structured Concurrency with Coroutines", this talk take a light-hearted approach at some of the colorful developments Android has gone through the years.
From “Why did AsyncTask get deprecated?” to resource leaks in background threads, we look at memory leaks in Android as we’ve uncovered them through the years. To understand quirks of memory leaks in Android, join us for some historical context, a little empathy, and a kinder view of open-source development.
Kotlin and TornadoFX: The Next Frontier in Modern (Meta)Programming
With growing complexity in our software systems, technology companies now dedicate greater effort to design product infrastructure to ensure modularity, low-cost solutions, and scalability. Object Oriented Programming (OOP)'s tendency of designing object-models for domain solutions in addition to its merits in handling large data and reducing complexity makes its usage a natural choice in the industry. Despite universal usage, Java's limitations in language techniques fail to capture all domain design decisions in a cohesive manner. This issue describes aspects of relational domains, in which scattering and tangling between mapped sources and targets forces large-scale projects to sacrifice domains that guarantees quality software.
Kotlin's open-source community is active, its uses are ever-expanding, and its future is bright. This session intends to analyze a general definition of crosscutting and how it affects growing software, how Aspect-Oriented Programming (AOP) attempts to tackle crosscutting, shortcomings in Java’s current approaches in reflexive programming, and subsequently discuss my experiences with TornadoFX in solving day-to-day business inefficiencies through my first attempt at metaprogramming. Exploration through examples will provide insight in Kotlin’s approaches to metaprogramming intended to expose Kotln's predisposition to AOP. By harnessing the power of Kotlin, we can make strides in creating a foundation for rational framework for metaprogramming.
2025 | NYC | droidcon Sessionize Event
2024 | NYC | droidcon Sessionize Event
KotlinConf 2023 Sessionize Event
2022 | NYC | droidcon Sessionize Event
2022 | Berlin | droidcon Sessionize Event
2022 | San Francisco | droidcon Sessionize Event
droidcon Lisbon 2022 Sessionize Event
2021 | London | droidcon Sessionize Event
2021 | Berlin | droidcon Sessionize Event
KotlinConf 2019 Sessionize Event
KotlinConf 2018 Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top