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 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 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 Edward Amsden

Nockchain is a solid-state blockchain: meaning we have implemented its consensus logic as a functional state machine on a solid-state runtime.The runtime automatically persists the state machine, and allows for direct functional, by-value reference to arbitrarily sized data, even data too large for working memory. This allows for extremely straightforward specification and implementation of the blockchain's consensus and transaction validation logic.Nockchain is also a NockApp. The NockApp framework allows developers to use the same infrastructure we developed for NockChain to leverage all of the advantages of Nock computation.

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 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 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 Isaac Shapira

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

With Jayneeta Sinha

Tiny but Mighty: Building Lightweight Models That Love Your Local FilesIn a world of overflowing folders, endless documents, and scattered data, wouldn’t it be great if your local machine could do the heavy lifting for you?

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 Martin Förtsch

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 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.

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.