Hisham Muhammad

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?

"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?

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.

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 talk in which I discussed the challenges on typing dynamic languages and Lua in particular, presenting the results achieved since then.

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.

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

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.

About the speaker: Hisham Muhammad is the original author of htop, a project started in 2004. Hisham is also the lead developer of LuaRocks, the package manager for the Lua language and a co-founder of the GoboLinux distribution.

Session with the GNU Guile and LUA communities

Session with the GNU Guile and LUA communities

This talk will present LuaRocks, the package manager for modules for the Lua programming language. Lua has successful as a scripting language embedded into applications, especially in the gaming industry. However, its "no-batteries-included" design prevented it from getting traction as a stand-alone application language. LuaRocks was created to target this problem. This talk will discuss the particular challenges of developing a package manager for Lua. With this project, we've been successfully fostering an ecosystem of extension modules, improving reuse of Lua code.

Full Description

This talk will present LuaRocks, the package manager for modules for the Lua programming language.

Lua has been used for many years as a scripting language embedded into applications. It has been especially successful in the gaming industry, being present in several AAA titles. Its ease of embeddability, good performance and small footprint have been major factors it this success.

However, its minimalistic, "no-batteries-included" design has also prevented it from getting much traction as a stand-alone application development language. A major setback was the lack of an easy way to integrate extension libraries for various tasks (such as sockets, databases, UI, XML/JSON, etc.)

LuaRocks was created to target this problem. It is a package manager designed for Lua modules (written in Lua or C). 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 will discuss 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.

With the LuaRocks project, we've been successfully fostering an ecosystem of extension modules for Lua. The repositories keep growing, and the dependencies between modules show that reuse is increasing.

About the presenter

Hisham Muhammad (Rio de Janeiro, Brazil) — lead developer of LuaRocks. PhD student at PUC-Rio, the university where Lua is developed. Other projects include htop and GoboLinux. I've been involved with the Lua community since 2004 and I have given talks on Lua-related topics in a number of conferences.