talks

Slides and/or videos of presentations I’ve given:

Five years of Teal: minimalism versus growth in language design

FOSDEM 2024 - Brussels - February 4, 2024

Teal is a typed dialect of Lua whose genesis was chronicled in three talks at this devroom: “Minimalism versus types” (2019), “Minimalistic typed Lua is here” (2020) and “What’s Next for Teal” (2021). From a being just a wild idea back in 2019, the language has grown into a small community of users (roughly measured by its ~1.8k GitHub stars). With growth, the language’s strengths and weaknesses became more evident, and with those come feature requests. How to keep the language small and still address the needs of users, while remaining faithful to the spirit of Lua and not falling into pitfalls from the past? In this talk we’ll discuss some pragmatic choices in Teal’s design that were made to balance those concerns: to make it more powerful, while keeping it small.

LuaRocks and the challenges of minimalism

FOSDEM 2023 - Brussels - February 4, 2023

link

We love minimalistic systems, because their concise models fit our brains, and give us a sense of understanding of the whole in a way that is nearly impossible in other environments built around huge frameworks and the like. Lua is a minimalistic language — the source distribution of the language is about 360 kbytes.

However, in any minimalistic system or language, that nice base system itself is just the tip of the iceberg. Minimalistic environments are meant to be extended. How to avoid complexity from creeping in?

This talk will discuss the trials and tribulations of building LuaRocks, the package manager for a minimalistic language, aiming to nurture an ecosystem for the language while trying to keep its design true to the language’s principles. We’ll discuss lessons learned in the past 15 years of LuaRocks, and finally ask ourselves a question: is there such a thing as minimalistic software maintenance? What would that look like?

Adventures in Dataflow

FOSDEM 2022 - online - February 6, 2022

link

“How can we democratize computing?” — that is a sentiment echoed by many people, especially those of us in tech who realize what the general audience is missing out from computing devices, when they use them as passive consumers. If we think of computing devices as programmable tools for active exploration, how should they look like? What programming model should they be based on? It’s fair to assume that it shouldn’t look like what passes for regular programming nowadays, since that is clearly out of touch with users. Perhaps something more… declarative? …minimalistic? So, how can we bring declarative and minimalistic computing to the masses? And… maybe we have already?

What’s next for Teal, the typed dialect of Lua

FOSDEM 2021 - online - February 7, 2021

video (YouTube) • link

This talk is the third part in a trilogy of talks hosted at this devroom that chronicles the birth of Teal, a new programming language that is a typed dialect of Lua. In this talk I will present an update on Teal: we’ll talk about the current status of the language and its nascent community, and look forward at what lies ahead for its future. We will discuss a bit about the recent evolution of the project, and where it can go from here while adding more power to the type checking while keeping the language simple.

In Part 1, “Minimalism versus types”, presented at FOSDEM 2019, we talked about the previous projects that aimed at producing typed variants of Lua, the challenges they faced, and the idea of trying again with a focus on minimalism and pragmatism.

In Part 2, “Minimalistic typed Lua is here”, presented at FOSDEM 2020, I presented the progress of the project, with a compiler that is able to type check itself and compile itself into Lua code. At that point, the language was still called tl.

Now in Part 3, the language has a name (Teal!), and a growing community. In “What’s next for Teal”, I will report on the advances we’ve made in the last year, and also address the elephant in the room: people keep asking for features, the language keeps growing, the type system has already made it more complicated than Lua, what about the minimalism? For that, we need to go full circle, revisit what minimalism means in the context of types, and how to approach it in a Lua-like way.

Minimalistic typed Lua is here

FOSDEM 2020 - Brussels, Belgium - February 2, 2020

video (YouTube) • slides • link

In this talk I will present a typed dialect of Lua with a minimalistic implementation. I will discuss the design choices that went into the design, implementation and development approach. We will also discuss whether Lua’s minimalism is retained and ponder on the nature of the resulting dialect. This is a sequel for last year’s talk in which I discussed the challenges on typing dynamic languages and Lua in particular, presenting the results achieved since then.

Taxonomy of Package Management for Programming Languages and Operating Systems

PLOS 2019 - Huntsville, Canada - October 27, 2019

slides • paper

Package management is instrumental for programming languages and operating systems, and yet it is neglected by both areas as an implementation detail. For this reason, it lacks the same kind of conceptual organization: we lack terminology to classify them or to reason about their design trade-offs. In this paper, we share our experience in both OS and language-specific package manager development, categorizing families of package managers and discussing their design implications beyond particular implementations. We also identify possibilities in the still largely unexplored area of package manager interoperability.

Userland: creating an integrated dataflow environment for end-users

LIVE 2019 - Athens, Greece - October 22, 2019

video demo (YouTube) • slides • link

This is a presentation of Userland, an integrated dataflow environment for the development of end-user applications. This work stems from the observation of successful end-user programmable applications with proven industry track record, such as synthesizer software like Pure Data, the LabView graphical language and spreadsheets. Userland aims to replicate the dataflow execution style that sits at the core of those applications, and provide this core as a base for the modules written in scripting or systems languages that present themselves to the user as an inherently programmable application. In the current stage of the work, a base prototype with the core dataflow engine exists, as well as two applications: a basic spreadsheet and a Unix shell. The intention is that, by sharing a common programming paradigm and execution engine, these integrated applications will allow users to combine them in creative ways, producing functionality not originally envisioned by their original authors.

Minimalism Versus Types

FOSDEM 2019 - Brussels, Belgium - February 2, 2019

video (YouTube) • slides • link

We love minimalistic languages because they let us do so much with so little. But when we start doing a lot with them, often we start yearning for types to help us make sense of it all. Adding types to a minimalistic language (well, adding anything!) makes it larger. Is this worth the price? Is a rich type system antithetical to minimalism? Let’s find out!

This talk is based on the experiences in the development process of Titan, a statically-typed Lua-like language.

New features in LuaRocks 3

Lua Workshop 2018 - Kaunas, Lithuania - September 7, 2018

slides

LuaRocks 3.0 is out, and it contains a bunch of new features which are easy to miss out if you’re used to the typical LuaRocks workflows. In this talk, we’ll take a tour around the features of this new release, including the changes and simplifications of the rockspec format, and the introduction of project-based workflows, where you can install a separate set of rocks for a project and work with a private rocks tree without disturbing your main system.

Performance counters in htop 3

Linux Developer Conference Brazil 2018 - Campinas, Brazil - August 25, 2018

video (YouTube) • slides • link

Typical userspace process monitoring tools usually show traditional metrics such as CPU and memory percentages, but modern hardware provides much more data.

Performance monitoring nowadays needs to consider these metrics, such as instructions-per-cycle and cache usage, as they paint a better of hardware utilization, taking into account superscalar processing and memory hierarchy.

The kernel already makes this data available to userspace, but it’s currenly used only in advanced tools such as systemtap and perf-events.

This talk will present the new hardware performance monitoring metrics introduced in htop 3.0, hoping to bring these measurements to a wider audience.

Adding performance counters to htop

FOSDEM 2018 - Brussels, Belgium - February 4, 2018

video (YouTube) • slides • link

Typical userspace process monitoring tools usually show some general metrics like CPU% usage, Memory%, CPU time and so on, which have been around for a long time. In this lightning talk, I will discuss some other performance measurements available in modern systems, like hardware performance counters, and talk about their inclusion in htop, in hopes that these powerful metrics will reach a wider audience.

htop is an interactive process viewer for Unix systems. Typical userspace process monitoring tools, either textual or graphical, usually show some general metrics like CPU% usage, Memory totals and percentages, CPU time and so on. These are essentially the same set of metrics which have been around for a long time, since the days of the original Unix top.

However, newer process metrics have become available over the years, usually “hidden” in more advanced tools such as systemtap and perf-events.

In this lightning talk, I discuss some of these performance measurements available in modern systems, such as Hardware Performance Counters, and talk about their inclusion in htop, in hopes that these powerful metrics will reach a wider audience.

Lua Application Programming: Starting a Conversation

Lua Conf 2017 - Rio de Janeiro, RJ, Brazil - June 3, 2017

video (YouTube) • slides

Lua was created as a scripting language. But so were Python, Ruby, JavaScript and many others that are today used for writing entire applications. Can Lua be used for “programming in the large”? If so, what does it take to do application programming in Lua successfully? In this talk, we’ll look at pros and cons of using Lua as the main language in your programs, and share some tips on how to do it effectively.

Dataflow in End-User Programmable Applications

Libre Graphics Meeting 2017 - Rio de Janeiro, RJ, Brazil - April 22, 2017

video (YouTube) • slides

A lightning talk on my recent research on the semantics of dataflow languages in end-user programmable applications.

A história do htop - um “making of”

PHP Experience 2017 - São Paulo, SP, Brazil - March 28, 2017

slides

Essa palestra conta o “making of” do gerenciador de processos htop um projeto de software livre que começou de forma despretensiosa e se tornou uma ferramenta bastante popular. Vamos ver o que é o htop, desmistificar o seu funcionamento, conversar sobre as decisões de design que possivelmente influenciaram na sua popularidade e contar alguns causos do seu desenvolvimento.

What’s coming in LuaRocks 3

Lua Workshop 2016 - San Francisco, California, USA - July 9, 2016

video (YouTube) • slides

This talk will discuss LuaRocks 3, the upcoming major release of the Lua package manager. LuaRocks 3 will feature the first update of the rockspec file format since LuaRocks 1.0, released in 2008. I will present what is being planned for LuaRocks and its rockspec format, and take the opportunity to discuss with the community the directions we want to take the project from there on.

LuaRocks - the package manager for Lua

LuaConf 2016 - Rio de Janeiro, Brazil - July 9, 2016

video (YouTube) • slides

This talk presents LuaRocks, the package manager for Lua. LuaRocks showcases the potential of Lua as an extensible language, making a wide variety of modules available. The large availability of modules makes application programming in Lua a reality. Further, LuaRocks is also an enabler for cooperation between the ecosystems of various Lua-based applications.

Going cross-platform - how htop was made portable

FOSDEM 2016 - Brussels, Belgium - January 31, 2016

video (YouTube) • slides • link

The story of how htop, a popular interactive process manager, went from being a Linux-only application into a portable one. In this talk I will discuss the technical approaches taken in porting process, the design choices that went into it, and also a bit of the backstory on how and why this conversion came to be. htop is a popular text-mode process manager, originally written for Linux. Its original mission was to “aim to be a better top”.

For many years, it remained as a Linux-only application, because, while the UI was dependent only on the portable library ncurses, the entire logic for gathering process data was based on the /proc filesystem. In the spirit of free software, this didn’t stop enterprising users from porting it to different platforms, so htop ran, at different capacities, on FreeBSD (using a Linux procfs emulation layer) and Mac OS X, via an ad-hoc port that was never integrated back upstream.

It was not until 2015 that the htop codebase was made truly portable. In this talk, I will discuss how and why that happened, and talk about the challenges and design decisions involved. I will focus on the technical process, but I will also touch on the positive social impact to the project.

Programação orientada a objetos em C puro: o caso do htop

XVI Fórum Internacional Software Livre (FISL 16) - Porto Alegre, Brazil - July 9, 2015

video (ogv) • video (YouTube) • slides

Esta palestra apresenta as técnicas usadas no desenvolvimento de uma aplicação real em C, o monitor de processos htop. O htop é uma aplicação interativa para console, usando a biblioteca ncurses, mas foi feita usando um estilo de programação totalmente orientado a objetos. Veremos que programadores em C não precisam se render ao C++ para colher os benefícios da orientação a objetos nos seus programas. A abordagem que será apresentada é extremamente minimalista, e não depende de bibliotecas ou frameworks para programação OO. São discutidas as estruturas de dados usadas na construção do htop e algumas técnicas para simplificar a gerência de memória em uma linguagem sem coleta automática de lixo como C. É possível utilizar os conceitos típicos de orientação a objetos implementando-os diretamente. Programando em C, entendemos melhor o overhead de desempenho dos recursos da OO, e podemos “pagar o preço” somente quando necessário. Usando um estilo de programação disciplinado, é possível também “domar os ponteiros” de C e tornar os segmentation faults fenômenos infrequentes (sim! é possível!).

LuaRocks: fostering an ecosystem for Lua modules

FOSDEM 2015 - Brussels, Belgium - February 1, 2015

video (mp4) • video (YouTube) • slides • link

This talk presents LuaRocks, the package manager for modules for the Lua programming language. Its ease of embeddability, good performance and small footprint have been major factors in Lua’s success. However, its minimalistic, “no-batteries-included” design has also prevented it from getting much traction as a stand-alone application development language. LuaRocks was created to target this problem. It serves both as a package manager in the style of RubyGems or npm, and also as a build system for compiling C code into Lua modules. This talk discusses the particular challenges of developing a package manager for Lua. Some are technical challenges, related to portability; some are social challenges that reflect into technical issues, such as the lack of established practices.

What’s new in LuaRocks

Lua Workshop 2014 - Moscow, Russia - September 13, 2014

video • slides

This talk will discuss the latest developments in the world of LuaRocks, the package manager for Lua modules. It will start by introducing the LuaRocks tool, for those who are not familiar with it. Then, I will present what has changed in this past year: the move to a open repository, automation of the upload process and the latest efforts in making the tool more flexible. A revision of the format for specification files (rockspecs) has been long overdue, and in this talk we’ll discuss the changes needed to make the format fully extensible.

Criar software livre não é um bicho de sete cabeças: ‘the making of’ GoboLinux, htop, LuaRocks

XV Fórum Internacional Software Livre (FISL 15) - Porto Alegre, Brazil - May 10, 2014

slides

Essa palestra conta o “making of” de uma série de projetos de software livre nos últimos 15 anos: GoboLinux, distro alternativa criada ainda nos tempos de graduação; htop, o visualizador de processos interativo para Linux; e LuaRocks, o gerenciador de pacotes para a linguagem Lua. A ideia é incentivar as pessoas a seguirem suas ideias, mostrar diferentes modelos de desenvolvimento e como o software livre pode abrir portas — uma história que começou como estudante assistindo ao primeiro FISL.

LuaRocks - past, present and future

Lua Workshop 2013 - Toulouse, France - November 23, 2013

video • slides • article: “An informal history of LuaRocks”

This is a talk on LuaRocks, the package manager for Lua modules. LuaRocks was first released in 2007 and currently features over 300 projects in its repository [as of 2013]. The focus of the talk will be on the history of LuaRocks so far, its current status and latest developments, including possibilities for changes, especially revisions in the rockspec format. The idea is to hopefully open a discussion with the community with regard to future directions. (An accompanying article on the history of LuaRocks is available.)

Lua: an embeddable, high-performance scripting language and its applications

RIT++ 2013 - Moscow, Russia - April 22-23, 2013

slides • transcript

This talk will present the Lua programming language, with a focus on its applications. Lua is a portable, small, embeddable, but fully-featured programming language, with a core interpreter at about 180 kB. We’ll start with a quick look at the language features that set it apart in the world of so-called scripting languages, and we’ll its ecosystem, including the LuaRocks package manager. Then I’ll present a case study of Lua as used in a machine-to-machine (M2M) gateway application, where the language was used to script both low-level protocols, integrated with a server written in C, and to coordinate the business logic, integrating with a Java backend. Finally, we will take a look at some high-profile applications of Lua, both embedded in applications and as the main implementation language. Besides being widely used in the gaming industry, from Angry Birds to World of Warcraft, Lua has recently been integrated as the scripting language for Wikipedia, demonstrating its safety even when running unverified user code.

LuaRocks: o gerenciador de pacotes para módulos Lua

Hack’n Rio 2011 - Rio de Janeiro, Brazil - December 2011

video

Uma introdução ao LuaRocks.

LuaRocks 2.0

Lua Workshop 2009 - Rio de Janeiro, Brazil - October 6, 2009

(media not available)

O LuaRocks provê um ferramental para baixar e instalar módulos de extensão para a linguagem Lua. Esta palestra irá apresentar a ferramenta e discutir as novidades do LuaRocks 2.0, que redefine o sistema de armazenamento de módulos tornando-o compatível com o carregador de módulos padrão de Lua.