Talks

With Chris Krycho


Over the past decades, open source software has evolved from a novelty—frightening to some, dazzling with promise for others—to the bedrock of nearly all software development. (Consider: Thirty years ago, almost no major programming language was free or open source. Now it is all-but-unthinkable to launch a new language which is closed source, still less to charge for a compiler license.) It is tempting to construe open source projects as commons: cultural and natural resources we all inherit. But they are not. They are infrastructure. It is time we started treating them accordingly. The future of open source software—indeed, the future of software—depends on it.

With Dustin Getz

The central problem in frontend UI development is remote, over-the-wire maintenance of rich frontend views over large backend collections. Electric Clojure is a reactive Clojure dialect for fullstack web development that uses a dataflow compiler to choreograph the frontend/backend boundary, so that the application programmer need not code all the frontend/backend plumbing by hand.

Efficient remote distribution of collections is achieved through a new incrementally maintained collection type based on streams of collection diffs, which Electric uses to efficiently distribute fine grained collection updates to remote subscriptions by streaming diff values through a websocket.

In this talk we will demonstrate by live example how Electric Clojure and its differential collections let us build rich, interactive web products that arbitrarily interweave frontend and backend processes in a choreographed high performance dance, all without losing Clojure's dead-simple functional-lite composition model that anybody can understand.

With Alperen Keles

JQ is a powerful tool for manipulating JSON data, allowing users to express complex transformations in a succinct, dynamic, and elegant way. However, when something goes wrong, jq typically produces vague, local error messages that lack the context needed to help users diagnose the issue. In this talk, I’ll discuss how we can use static analysis to infer the "shape" of valid JSON inputs, and leverage this information to provide more meaningful, global error messages. This approach doesn’t require type annotations from the user, making it both practical and lightweight. I'll dive into the technical implementation of the inference procedure, the underlying principles, and how this technique could be applied to other languages with similar challenges. By the end of the talk, attendees will gain insights into how shape inference can enhance error handling in dynamically typed programming languages.

With Aaron Hsu

I'm known for doing a lot of work on terse programming styles in APL. This talk will focus on the one area of APL where I feel verbosity is the only answer I have at the moment, which is event-driven code, for which I apply a technique called Sequence-based Function Specification.

It just so happens to be a general strategy that can be applied to other programming languages as well, and may just help you write more reliable, consistent, and readable code for responsive applications.

With Aaron Hsu

Over the years, I've seen a variety of programming features become popular and then wane. There seems to be no end to new ones, but I have begun to wonder how much we have reflected on whether given language features delivered on their promises or not.

In this talk, I'd like to turn a critical, questioning eye on our most beloved programming language features and ask whether they really have delivered a better experience to us in total, or if we've only arrived at some kind of local benefit, potentially depriving ourselves of something better.

With Adam Hearn

Conventional streaming libraries like FS2 and ZIO require complex abstractions to manage behaviors like short-circuiting and signaling between producers and consumers.

Algebraic effects offer a simpler, more modular way to think about streams by treating them as first-class effectful computations.In this talk, we’ll explore how Kyo’s algebraic effect system redefines stream composition, making it possible to handle complex stream patterns with minimal boilerplate.

Through Emit and other effects, streams become just another type of effect, composable and flexible in ways traditional libraries can't match.

With Adam McCullough

We are faced with a contradiction: the mental tools we've learned from programming in languages like Haskell and Scala work, well, even under the pressures and constraints of industry-style development (that is, rushed and unpolished).

Despite its effectiveness, the language has been all but entirely left behind in the job market, even if many of the ideas (lambdas, stronger types, Maybe, constraints, just to name a few) have been picked up in mainstream languages.How do we reconcile these points? This talk will go into the externalities that drive adoption, what FP language communities tend to miss, what Industry tends to overlook, and how we, the people caught in between, can do to help the situation.

With Alex Pshenichkin

Pure functions are great. Everyone loves pure functions. Turning a complex process into a pure function can cut through a lot of otherwise-intractable computer science and engineering challenges — but that path itself is impossible, annoying, and hellish. Well, with the power of systems programming, we did it anyway. To the entire computer. Thanks to very selective emulation and some carefully crafted system constraints, we can apply a pure-functional view to the normally stateful and side-effect-riddled world of big programs running on real hardware. In this talk, we explore a full-featured implementation of a deterministic hypervisor, tailored to Antithesis' needs as a DST (deterministic simulation testing) platform.

With Alex Snaps

Whether you are deploying your application on Kubernetes or not, chances are high your application sits behind a proxy. Certain proxies can do more than just route a request to an endpoint. A few years back, Envoy started supporting Wasm as a way for users to run custom filters within the proxy’s process, which lets you do… “stuff”… In this session, we’ll go over how Kuadrant leverages that extension point of nowadays proxies to support use-cases like authentication and rate limiting.

We’ll then explore how much more can be done with the Wasm proxy ABI and the open source Rust SDK. With these tools, developers will be able to leverage the power of Rust & Wasm to provide their users with the best experience possible, while maintaining lean & slick deployment of their applications and keeping both their cloud costs & latency under control. By the end of this session you’ll be able to see how to leverage the Wasm Proxy ABI to bring your server-side applications to the next level.

With Adam Krebs

The web platform is powerful. Isn't it time that our UIs evolved to meet it?

In this talk Adam Krebs from Joby Aviation shows a visual programming language that he built for creating data driven geospatial animations in the browser, inspired by TouchDesigner and Houdini and capable of rendering to video or creating one off interactive apps.

With Brian Cardella

Year after year, Elixir is ranked as the most desired programming language. Come learn why Elixir is the most simple, beautiful, and powerful programming language on the planet.

With Ben Hindman

Over the last two decades, backends have evolved from simple monoliths to complex distributed systems, incorporating microservices, serverless functions, multiple databases, event queues, and more.

These architectures improve scalability and modularity at the cost of significant complexity in managing data consistency.Even without the extra complications in the backend, the inherently distributed nature of the frontend and the backend was already complicated enough.We present a new programming model for building full-stack distributed systems that unifies application logic with data management.

The programming model relies on built-in primitives for reactivity, atomicity, and idempotency that dramatically simplify development without sacrificing safety or scalability.Instead of thinking in tables and rows in a database, developers think in data structures and functions, and the programming model provides a well-defined semantics for how those functions can be composed safely together.While well suited for a new programming language, we’ll demonstrate the programming model using an implementation for TypeScript..

With Casey Allred

In the chaos that is software development it is important to stay in control of our software and our software development process. Like a scientist controlling their experiment, software developers need to have controls for their applications. These controls allow you to setup the application in a known state to verify functionality. In this talk we'll discuss why you should have controls and how to create them.

With Daniel Vigovszky

After using test frameworks like ZIO Test in Scala for years, Rust's built-in testing capabilities feels limited. To fill the missing gaps I wrote a new test framework called test-r. In this talk I will show some of the features test-r brings to the Rust ecosystem, how they are implemented, how they are used in the test suite for Golem Cloud, and show the tradeoffs made in order to emulate the built-in test framework - possibly the most important aspect of this new library.

With Eric Torreborre

Programming with functions is great. However, when growing large applications, programming with _modules_ is even better. And, at scale, being able to easily modify the graph of modules becomes essential. This is exactly what an effective dependency injectionsystem should provide! Unfortunately many FP languages do not support dependency injection out of the box.This talk will first present the criterias for what makes a given dependency injection system effective. It will then show how we can implement such a system for a language like Unison.Unison is a functional programming language with no support for meta-programming and limited support for abstraction; it only provides an effect and handler type system called "abilities". We will see how we can implement our own dependency injection system with abilities and finally list the programming languages features which could help us to improve that system.

With Esteban Marin

We’ll explore physics through Scala/Haskell, using the type system to clarify Newton’s Second Law, perform numerical approximations, encode vectors, derivatives and differential equations to create dynamic graphs and animations. For those interested in FP, math and physics.This talk is inspired by Scott N. Walck’s book Learn Physics with Functional Programming (written in Haskell), which explores fundamental physics laws like Newton’s Second Law, Coulomb’s Law, the Biot-Savart Law, and Maxwell’s equations. Due to time constraints, we’ll focus on Newton’s Second Law, using Scala and Typelevel libraries.

Our approach mirrors the book’s engaging style, demonstrating how functional programming can make math and physics both accessible and exciting. My goal is to inspire more Scala developers to explore the powerful Typelevel libraries for writing math in functional programming.

With Foy Savas

Lambda this, lambda that. But what about box and diamond? In this talk we'll go over the history and impact of temporal modal logics. From teaching sand to think to verifying network protocols, you'll learn why some programming languages will always be so devastatingly bad at math.

With Flavio Brasil

Kyo, a cutting-edge effect system in Scala 3, introduces a novel approach to composability through algebraic effects. This talk will present a type-safe method for structuring LLM interactions based on Kyo effects, introducing an algebra of thoughts that simplifies complex AI workflows. We’ll demonstrate how this approach enables explicit modeling of AI capabilities, simpler management of LLM context, proper resource management, and seamless integration with Kyo's comprehensive suite of effects.

Additionally, we will explore how Kyo’s effect tracking can serve as a sandboxing mechanism, facilitating safe and controlled execution of code generated by LLMs. Join us to see how Kyo’s algebraic design can transform how we think about and build reliable, scalable systems for next-generation AI.

With François-René Rideau

We will go on an adventure to automate the merkleization of arbitrary data structures, along which we will visit concepts including recursion schemes, generalized polynomials, derivatives of data structures, zippers, lenses, reference functors, content-addressing, metaprogramming, incremental and modular programming (aka OO), and category theory.

With François-René Rideau

_Orthogonal Persistence_: You bind variable `x` to 42 at your REPL, but then some “youths” steal your laptop while orcs raze your datacenter to the ground.

So you move to a safer place, get a new laptop, and enter your passphrase in it; the system downloads encrypted backups from redundant data centers on multiple other continents; after a few minutes, your interface is restored to the same state it was when you left it, and variable `x` is still bound to 42.Yet not one single instructions in any of your applications ever hadto even mention anything about storage and retrieval.

I will present an original re-framing of Orthogonal Persistence, as refactored into a simple set of concepts. Surprisingly perhaps, I will explain why transactions provide an inherently bad non-modular API, while their opposite, "anti-transactions" (critical sections) are good and modular.

With Harry Kimpel

WebAssembly (Wasm) has revolutionized client-side performance, but its potential on the server is where things get truly exciting. With new capabilities and tools emerging, WebAssembly is positioning itself as a game-changer for cloud-native applications, microservices, and more. But as this technology evolves, so does the challenge of understanding what’s happening behind the scenes.

With Hongbo Zhang
‍
MoonBit, a modern and practical programming language, is taking a significant leap forward with the introduction of its asynchronous programming model. This talk provides an in-depth exploration of MoonBit's new async feature, designed to simplify the development of scalable and efficient applications, particularly in the realm of micro-services.

With Haoyi Li
‍
Mill is a JVM build tool that lets you write pure-functional build code to compile Java  projects 2-10x faster than existing tools like Maven or Gradle. This talk while explore how Mill uses pure functional programming to provide a uniquely intuitive developer experience, while at the same time moving heaven and earth to bridge the gap between pure-functional elegance and the messy filesystem IO, subprocess spawning, concurrency and state management necessary in any real-world build system.

With Isaac Shapira

What is power in programming languages? Why won't it save us. And how we can do better.

With Isaac Harris-Holt

Modern software engineering can be a bit of a nightmare. You've got all these different third-party services to keep track of, and often many first-party microservices too! As it turns out, things can be made more simple.How? Using Gleam, of course! This talk aims to be an introduction to why you should be using Gleam on the backend and how you can use it to simplify your application's architecture.

Talk objectives:- Introduce Gleam as a solid choice as a backend language- Explain Gleam's benefits - type system, no runtime exceptions, etc.- Walk the audience through a sample project with a cache, background jobs (repeated and using a job queue) and show that it can all be implemented in a Gleam project without external services.

With Jack Danna

Join me for an authentic journey through the challenges and victories of developing the Fogent Roleplay Web Application using Full Stack F# and the Model-View-Update (MVU) architecture. Drawing from firsthand experience, I'll introduce you to the powerful F# SAFE stack and break down MVU state management in accessible terms. Whether you're an F# enthusiast or just curious about functional web development, you'll walk away with practical insights into real-world implementation, common pitfalls to avoid, and battle-tested best practices that can enhance your own projects.

With Jim Duey

Recursion is hard. Recursion Schemes are even harder because they're more abstract. But that abstraction can deliver great power. Unfortunately, the topic is wrapped in a daunting universe of terminology, abstract concepts, and a reliance on Haskell for examples. This talk will seek to cut through all that and give you a basic understanding of this abstraction to help you level up your skills.

With John De Goes

In the era of cloud-native programming, endless data flows across the Internet, updating state and triggering effects along its path. Though most wire protocols are untyped (like JSON) or poorly typed (like Protobuf), fans of static types prefer to tame the complexity of the cloud with statically-typed persistence and cloud APIs.To bridge the gap between the typed world and the untyped world, sometimes code generators are used.

Another option, demonstrated in the library "ZIO Schema", is to encode the very structure and capabilities of a user-defined data type as a value, and then programmatically derive codecs and relational data mappings from this structure, which allows elimination of boilerplate but preserves type safety.In this presentation, functional programmer John A. De Goes will walk through his design for ZIO Schema 2, which is superior to its predecessor in every way--flexibility, performance, and beauty. As you learn the secrets of this new library, you will see how the approach compares to Rust serde, and discover the magic of reflective optics--a new construct that John devised to simplify common problems in everyday programming.Finally, at long last, fans of strong static types can have the usability of dynamic programming, but with compile-time guarantees and no runtime overhead!

With Jon Pretty

Correct software must handle every deviation from its happy path. Functional programming provides exactly the safety guarantees we need to build it.But it comes with a heavy syntactic burden: try telling an Java programmer they must use `map`, `bind` or `traverse`, when all their experience is of first-class member selection, function application and thrown exceptions. Is it any wonder FP is such a hard sell when even JavaScript expressions compose better than monads?Now try convincing a functional programmer they no longer need to encode failure in monads, when years of successful use has made them second nature.

Nevertheless, this is what I shall attempt.Soundness, a new ecosystem of libraries for Scala 3, offers an uncompromising alternative: the expressiveness and compositionality of direct-style Scala with incrementally-checked exceptions, and without the slightest compromise on safety.I'll show you how to write code that's as readable as Python and as safe as Haskell; where the transition from prototype to production is a seamless continuum of gradual enhancement towards totality. I'll show how Scala 3's context functions are the perfect mechanism for encoding partiality, how they make exceptions safe again, and how this can lead to a new utopia of safety and elegance.

With John Konecny

The video game Factorio is a perfect visual and practical representation of how ALL software is designed, whether intentionally or not. As software developers, we can use this fact to design better systems before writing a single line of code.To do this, we simply need to start using the tool all engineers know and love: math!This talk is for all experience levels.

With John Anderson

Leaky Abstraction, and the observation that every big-enough program evolves configuration which tends to turing completeness. Leans on Peter van Roy's classification of programming paradigms.

With Kian Wilcox

Programs written in functional languages are similar to poetry in their elegance and semantically density. Programs have written poetry, and some poems are executable. Despite the close relationship between poetry and code, the use of recursion and co-recursion in poetry is under-explored. In this talk we introduce MetaVerse, a notation for writing "meta-poems" which express poetry with fractal structure.

With Martin Förtsch + Thomas Endres

This talk introduces you to the world of generative AI with a focus on Text-to-Image, Text-to-Audio and Text-to-Video for creating images, music and short videos. We explain how neural networks can generate various output formats from short text inputs using diffusion models and so-called Transformer architectures.

With Travis Frisinger
‍
Large language models (LLMs), like GPT-4, are sometimes viewed as simple next-word predictors with a limited understanding of the tasks they perform. Despite these apparent limitations, LLMs have proven to be incredibly useful tools across various domains, from content generation to automating complex workflows.

With Lakshmi Narayana Rasalay + Raghavan Sadagopan
‍
Building modern applications that are both highly resilient and scalable is essential to meet the demands of today's dynamic environments. By leveraging multiple interconnected AWS services, developers can create complex distributed architectures that support scalable, fault-tolerant, highly resilient and event-driven applications.

With Max Gfeller
‍
Everyone keeps calling 2025 “The Year of AI Agents,” but big-name tools like Devin rarely live up to the hype. They’re expensive, they’re slow, and they often don’t deliver exactly what you need. In this session, we’ll show you why going custom is not just another trend but the real key to reaping the benefits of AI code generation.

You’ll learn the fundamentals of building specialized AI agents that handle tight-scoped, high-impact tasks—exactly the sort of work that bogs your team down when you’re trying to move fast. By the end, you’ll be ready to drop custom agents right into your codebase to automate the repetitive parts of development, letting you focus on the more creative, challenging problems that keep you and your team energized. Let’s ditch one-size-fits-all solutions and start shipping features that actually matter.

With N.E Davis
‍
A vase is a pair of type and data, particularly as used in Nock and related languages.  Vase mode, therefore, describes working with such pairs rather than first-order typed data.  The vase algebra allows types to be straightforwardly combined, permitting code evaluation, facilitating metacircular interpretation, managing persistent code artifacts, and otherwise working at a higher level of abstraction than raw typed code and data.

In this talk, we will examine the role of vases, the vase algebra, and work through several examples of how and why vase mode is useful throughout Nock-based platforms.

With Oren Rozen
‍
In this talk, we'll explore the power of compile-time programming in C++14 by delving into the design and use of compile-time types. Through simple templated polymorphism driven by enum values, we'll show how you can leverage constexpr functions to compute values during compilation, drastically improving performance and reducing runtime overhead.You'll also see how to serialize these types at compile-time, demonstrating the efficiency of working with types without the need for runtime computations.

Finally, we’ll explore parsing these serialized types back into their original forms using handwritten parser combinators, showcasing the flexibility of C++ for functional programming at compile-time.This session will provide a hands-on look at how functional programming paradigms can be applied to C++ to enhance type safety, performance, and overall program design—all while staying within the boundaries of C++14.

With Paul Snively
‍
This talk will offer a broad overview of Epic Games' Verse language, with a particular emphasis on its influences (Ontic, Icon, Curry...); its relationship to existing Epic Games languages, both implemented and unimplemented (UnrealScript, Blueprints, λℵ); its intention to serve as a new foundation for functional-logic programming (the Verse Calculus); and its novel Curry-style type system. Some discussion/speculation of Epic's motivation will be included, hopefully with audience participation.

With Paulo Valente
‍
In this talk, we'll learn about the Nx (Numerical Elixir) ecosystem, and how we can use the tooling for training a model and then use it in a Web application. In the process, we will discuss why Elixir can be a good alternative for Machine Learning, how the Nx ecosystem reached its current state, other characteristics of the Elixir programming language.

With Peter Saxton
‍
The software of today is fragile. It decays over time due to outdated dependencies or environmental changes like new hardware or operating systems.This fragility erodes confidence when creating software, and precludes some people from even trying to create software. The EYG language removes fragility through a combintion of effect types, structural typing and deterministic dependencies.This session introduces each of these features and shows how their combination leads to confident development and robust software.

With Pierangelo Cecchetto
‍
In the past year, I had the chance to work on business modeling problems that found brilliant solution in functional domain modeling.This provides a precise but flexible way to describe and implement solutions. We will see how we can take the same solution and implement different interpretations, e.g. for business logic and for visualisation or documentation.The basic solution is Scala-based but we will see what other languages have to offer in this regard.

With Rajani Ekunde
‍
Intelligent workflow automation with AWS Lambda and AI models enables businesses to build dynamic, serverless systems that make data-driven decisions in real time. By integrating Lambda with services like Step Functions, SQS, and SNS, AI models can be seamlessly incorporated into complex workflows for tasks such as personalized recommendations, fraud detection, and predictive maintenance.

This architecture ensures low-latency processing, scalability, and cost-efficiency by eliminating infrastructure management. With AI-driven decision-making, organizations can automate workflows, enhance operational efficiency, and improve responsiveness, enabling faster, more intelligent actions across various use cases, from customer service to system health monitoring.

With Raphaël Lemaitre
‍
In a live-coding session, I'll demonstrate how Pillars simplifies Scala backend development by integrating essential libraries for observability, database access, API calls, health checks, and more. Watch as we go from zero to a live-deployed, production-ready service in just 50 minutes.

With Ryan Orendorff
‍
In this talk we will discuss Sunscreen's new approach to FHE program creation where a developer writes regular C code that is transformed into a performant, secure FHE application able to process encrypted data without ever decrypting it. This is possible due to two technologies: (1) a novel virtual processor design that generates a representation of FHE programs in a parallelizable, portable, and compact way, and (2) a compiler that converts normal C code into the instruction set of the processor.

With Sabine Schmaltz
‍
While OCaml has long been valued in industry and academia for its powerful type system, memory safety, and performance characteristics, its tooling ecosystem has historically presented barriers to newcomers.

This talk explores Tarides' recent initiatives to transform the OCaml developer experience through modernized tooling, streamlined workflows, and intuitive interfaces.We'll give an overview of initiatives, such as the Dune Developer Preview and Dune Package Management, look at the current state and recent improvements of editor integrations to support OCaml development, as well as give an outlook on what is coming.

By removing barriers to entry while preserving OCaml's core strengths, we aim to make functional programming more accessible to the broader developer community. This talk will interest both experienced functional programmers curious about OCaml's evolution and newcomers looking for a type-safe, high-performance alternative to mainstream languages.

With Sameera Jayasoma
‍
Let me take you through my journey of building an open-source internal developer platform (IDP) that makes cloud-native application delivery a whole lot easier. I'll show you the key building blocks we created - organizations, projects, environments, components,  deployment tracks, Build, and Deployments - and how they come together to create a platform that developers actually want to use.I'll dive deep into how we:

- Architected a multi-tenant system that elegantly supports organizations, projects, and environments through isolated cells- Implemented a control plane/data plane separation inspired by Kubernetes for robust scalability and reliability

- Created intuitive abstractions that shield developers from infrastructure complexity while preserving full flexibility

- Designed deployment tracks that support sophisticated delivery patterns including canary and blue-green deployments

- Established a component model that enables standardization while supporting diverse workload types, all while using cell-based architecture for better isolation and scalability

Whether you're comparing existing platforms or building your own, you'll walk away with practical insights into how intuitive abstractions, cell-based architecture,  Kubernetes-inspired patterns, and modern platform design can create an IDP that truly works for your teams.

With Theodor Thornhill
‍
Today, deploying applications in the clouds is essential for almost all companies.However, increasing computing costs along with architecture complexity makes working with the cloud almost prohibitively expensive.Not only that, the negative impact on the planet cannot be understated.We will see how we reduced our cloud costs by ~80%, delivering more stable architecture, reducing maintenance burden and developer headaches.

Zig, golang and the audacity to write things ourselves has given us the possibility to be a positive influence on the planet, causing optimism for the way forward.

With Valentina Halasi
‍
The rise of reasoning models, such as OpenAI’s o1 and DeepSeek R1, represents a significant evolution in AI capabilities. Unlike traditional LLMs, these models excel in step-by-step problem-solving, logical reasoning, and handling complex, multi-step tasks across fields like mathematics, coding, and research.

This talk explores how reasoning models differ fundamentally from their predecessors, the problems they are uniquely equipped to solve, and the breakthroughs we can expect in the near future, such as enhanced multimodal reasoning and long-term planning. Discover how reasoning models are shaping the next frontier of AI innovation, and how you can efficiently apply them in your projects.

With Zach Mitchell
‍‍
It’s very rare that a technology changes how we build software. Containers allowed us to bundle up a developer environment and isolate it from the host system. Nix allowed us to be rigorous about our dependency tree and build software reproducibly. The next generation of developer environments will pick up where Nix leaves off and make it accessible.

Taking things even further, the next generation of developer environments will be *composable* so that your developer environment can context switch and keep up with you as *you* context switch. In this talk I’ll show you that, with Flox, the tooling for this next generation of developer environments already exists.

With Will King
‍
Subtitle: A framework for ambitious projectsI had never written a line of Gleam before deciding one day to build an entire game engine. I hadn’t even built a game on an existing engine. But I dove in, and along the way, I have uncovered lessons worth sharing.In this talk, I’ll explain why I picked Gleam to build a game engine, and reflect on the most important takeaways I have found (or that found me).

## Why Gleam?
‍
Gleam is a strongly typed, immutable language. When building a game engine there are two things that make Gleam a no brainer.

### Constant Loop of Updates
‍
Strong types and immutability help avoid unexpected side effects that can quickly pile up in a game loop when building reusable systems (animation, rendering, camera & focus). Allowing you to safely operate on your game state in a constant loop.

### Full Power of Two Runtimes
‍
Gleam compiles to both Erlang and Javascript. This means my server can leverage the full power of the BEAM, while I take advantage of the browser on the client for rendering the graphics.

## Takeaways

Some insights are technical—like how to navigate browser quirks and tackle performance challenges. Others are about mindset, such as breaking down impossible problems or starting before you have all the answers. I’ll even touch on why you don’t need the “perfect” data structure to get things done.

## Why this talk matters?

1.    We need more people to realize you don’t need special knowledge or permission to start building something awesome.

2.    Sharing practical techniques, lessons, and also failures will help them find success when they decide to take the leap.

Let's inspire more people to just dive in and chase ambitious ideas!

PS - I’ve been sharing my journey in my “Game Dev Logs” if you want to poke around:
•.   [Game Loop](https://wking.dev/logs/game-loop)
•.   [Update Loop](https://wking.dev/logs/update-loop…)
•.   [Render Loop](https://wking.dev/logs/render-loop…)