All right, hi everyone, I'm Hisham, and of course the obvious thing to say is that like
Christine's a tough actor fall, like after all that energy, but yeah, I think we're going
to, one thing is down a bit and get a bit philosophical about first software maintainership,
project directions and all those kinds of things, so I think it's going to be pretty
chill. And yeah, so as many of you know, and I see many friends here, I have, I have
started several, this is feeding back a little like, but I hope it's okay in the recording.
I have started several for software projects myself, and I guess maybe one of the takeaways
of this talk, probably of all my talks, is to try to encourage people to start their own
little projects, like I love big visions and I love big communities, but personally my thing
has always been like starting little projects and I've done a few of them, and with very
outcomes, and some of you have mentioned before, like I think like the most popular one is
a stop, the process viewer, which I've worked on for about like 15 years or something,
and yeah, and that got like, you know, that got really big and popular, and another one
which is, which found its niche is Lourox, the package manager for the Louro programming
language, so that also started as a small project and ended up getting like, lots of
usage, at least like within the small universe that is the world and it's very subcommunist,
and, but then again, I also made like my own little text editor, which I use as my daily driver,
and which I have like basically like one user, and I get surprised when someone sends an email
or something, and I don't expect anyone else to use it.
So yeah, so here, when we talk about minimalism and many of the talks that we see here,
we often talk about small projects, and like, it's fair to see those things as small projects as well,
and, and when we look at the history of how it went, like, many people know the story,
like I have maintained the H stop for like about 15 years, and if you look at the
commit graph history and my commit graph history over there, like I'm, I'm happy to report
that I have been since overtaken in the number of commits, like by one of the current
maintainers, but basically like up to like the first three quarters of the graph,
they pretty much like matched my graph there, and then we have this like flurry of activity
now that there's a new maintainer team carrying on with the project, so I'm super happy
about that outcome over there, and, and I can tell you like at that point somewhere around
there, after the less big bursts that I did, I won't point like I was happy with
it, everything I needed, you know, the whole scratcher on edge thing was done, and I honestly
felt like the project was finished, and, and really like, I pretty much lost interest in it,
right, so I'm happy there is people who are interested, I've met, just met here, it falls
them, been one of the current maintainers, like, bandy here, for the first time, in person,
and it's been, it's been an awesome experience, like on the other hand, like, the little text
editor, you know, it keeps going like, they're not up to the same scale, but like,
it just keeps going, like if I need something, I may have a little change, and it just keeps going
as my own little project, right, which basically my current like focus on excitement, my current
will project, which is teal, teal is, you can think of teal as what type script is to JavaScript,
so basically like teal is a pun on teal, like those of you who were the 2019 fuzzling talk,
when it still didn't have a name, the working title for the project was teal, and I kept calling
it teal teal teal teal teal and it, like, and I like the color, so, and, and just, like, so yeah,
that was 2019 me talking about it, and so this is, like, a type, dialect of Lua, and Lua,
sometimes I forget to talk about Lua, and to give a bit of a primer, right, Lua is this dynamic
language, which is, was developed in Brazil at the Pucario University at Rio de Janeiro,
and in the, in the 90s, so, at one point in the 2000s, when I was like, thinking of applying
to Grasco, Lua was the only programming language, like, that reached the main stream that was
not developed in the global north, so, actually it was like, one of the two only ones that were
not from Western Europe or the United States, because the other exception was Ruby from Japan,
and so, is this scripting language that's super small, it's designed to be embeddable,
so it found niches in networking areas and up working with it a lot in that field,
gaming industry, mainly, and embedded systems, and to put a human face to it, here's a picture
from, I think, was last year, like, when we celebrated, like, 30 years of Lua, there was,
they held a workshop in Rio de Janeiro, like, that's me, next to, to hold back the crates,
are the language, there's Hogo, who's greater of Pauline, and, like, many other, like,
of the alumni, and the next generation, like, the current undergrads in Rio, and the project
keeps going on. And so, the idea of Tio was kind of, like, Lua, but for programming in the large,
because Lua's design is this tiny, and we're talking about minimalism here, Lua's design is
this tiny, minimalist language, but that doesn't stop people from using it, like, people end up,
like, oh, I like Lua, it's so tiny, like, me start picking, writing more, more, more, more,
stuff with it, so, in the end, people end up writing, like, entire applications, such as um, Lua rocks,
uh, which, uh, it was not the right way to do it, because, like, in the end, like, it becomes kind of
unwieldy, right, and being, like, a PL nerd, like, instead of, like, rewriting it in a better
trice of language, no, let's make another language, so it can still keep writing it in Lua, but,
but now it's type safety. So, uh, this is not really a coding talk, so, but just so I have, like,
one slide with code, here's like a quick taste of Tila, it really looks like Lua, but then, like,
the Tila colored bits are, like, to type annotations, we have, like, new operator here and there,
and things to deal with types, and uh, this is a bit of foreshadowing on, like, uh, some of the
things I want to talk about for, like, Tila's hazelnut, right? Uh, so Tila has evolved over the years,
like, it starts from that little personal project that I presented in 2019, and now it has users,
it has people who complain about it, it has people who, uh, send bug reports saying that the
compilers do slow, and they're compiling hundreds of files at the time, and I go, like, oh my god,
you have the Tila project that has hundreds of files, right? So, basically, I'm not the largest
two user anymore, like, by, oh, by far, right? So, uh, so we do have a community that that has
evolved around it, and, and I talked about it last year here, like, uh, you know, presentation
call it five years of Tila, and an interesting thing was like this, uh, like, uh, this, uh,
thing of, like, minimalism versus growth, like, this challenge that was already in place, right?
And, and I talked about things of language design, and I talked about how people wanted safety,
and to keep it in the minimalistic type thing, I thought, like, okay, how about instead of
Neil safety, we give them, like, function error checks that would take them, like, a good deal of the
way there, right? And then, I talked about how people wanted objects, people doing games, they love
modeling their objects, so in the game world, there's an, using object orientation,
and instead of, like, giving them a full-blown class system, I was like, okay, how about
I give you interfaces with sub-typing, right? So, uh, my whole, the whole thing of the talk was
how I was, how I was working on designing alternative solutions that we're trying to keep the
minimalism of the language, right? And that's what it did. Uh, Tila, 2024, 2024 was released in
October, uh, 2024, and it did include all those, uh, all those things, right? So, it didn't
quickly air to checks, which was essentially now, and you don't have, like, optional types,
but you have optional arguments, right? So, that things that used to be valid, such as, like,
passing not enough arguments, because Neil is an implied zero type, zero object in every type,
this used to be valid by now fails. So, it did give people more safety, right? And,
air to checks were a success, because if you think back to it, like, this is something that was
a valid thing that used to be accepted by the language, and sometimes it's what people actually
wanted for it to be accepted. So, this was effectively a breaking change, and I was super
scared of making a breaking change that was like, okay, people will now update their compiler,
and now they're old, cold, no longer compiles, how are they going to react to that, right? So,
so it took some talking to the community and, uh, reviewing what we'll be the alternatives for
to dealing with that. So, if we eventually set up like a system with, like, there's a
pragma that you can put in the code for enabling or disabling RIT checks, so that's, like,
if you're requiring some other library that hasn't been converted to the Neil's tile yet,
you can temporarily disable it, or if you're in our project hasn't been converted yet,
you can pass it like a command line flag, like, I made it very, like, optional, but I turn it on
by default, like, this is the new way the language works, right? And, uh, and I'm saying this was
a success, because the feedback I'll got out of that after putting it all in the world and
close my eyes and see, okay, I'm breaking people's code now, what's going to happen?
Radio silence, like, I, nobody talked about the airy-teachets feature since it was out, like,
except for maybe one or two people in the chat say, well, it caught some bugs that I had, like,
now it fixed, they're like, put the question marks in and, and like, I got, like, a little bits
and pieces of positive feedback, but apart from that, it was, like, silence. And, and I did mention
that in last year's talk about how, like, you know, Persaurus most of, like, almost all of the
feedback that you get is negative feedback. You have to come to conferences to meet people and people
say, hey, I love your work, right? But people don't do it online, like, people are not going to
email, thank you. So, uh, yeah, right? So, you have to, so, one small takeaway, like, take silence
as a, right, you're doing good. And then I added the interfaces thing, right? So, the interfaces thing
allowed you to do, uh, things that you couldn't before, such as making unions of different
table types, and so that you could use the new, like, is operator for, uh, discriminating those,
those unions. And I added, like, a mini macro system that could tell the compiler how to expand
those, uh, is checks. And, uh, and across interfaces, we could have, uh, subtyping. So,
this was a big undertaking, because Tio already had generics, and how those things interacted
with the big, kind of worms, like, most of my work that I last year until went on this, right? So,
I, but, and then this was, like, an entirely new feature, which was, like, entirely optional. You could
just never put an interface and just continue using records, just not use this, not use this,
not to use that and continue using Tio as always, right? And ignore this feature entirely, right?
Unlike airy checks, which were breaking change that I imposed on everyone. And interfaces, I guess,
were a success, because I got the other type of feedback. I got a ton of bug reports. I got
lots of negative feedback on interfaces, but it was not negative feedback of the kind of,
oh, this feature sucks. No, it was, I like the feature. I tried to use it, and this part doesn't
work. Or I tried this, like, weird combination, and it failed, like, all of those other cases that
I haven't checked, right? Uh, yeah. So, like, this is, like, a filter off the issues list, like,
bug bugs and, and all of the things, when people started, like, trying out, uh, trying out
interfaces. So, uh, yeah. So, like, after that, we worked on it, like, 24.0, 24.1, 0.2.3,
and then we worked out on the issues, like, all of these issues are closed now. And, uh, but the
interesting thing was that the feedback was not only about bugs. Uh, the feedback was also about,
like, I'm trying to use the feature, but it feels weird, like, I'm failing to achieve what I'm trying
to achieve with it. And, uh, yeah, because, because, and then again, like, another thing is that,
like, not of all of the issues here are red. Some of them are, like, yellow. Have the yellow type,
which is, like, semantics. It's like, people asking questions. I'm trying to do this, but it doesn't
work. And then, uh, and then I have a, I'll reply saying, yes, it doesn't work because,
semantic reason, x, y, z, and they go, okay, so I'm going to try something else, right? And then,
okay, that doesn't work either. Or, oh, yeah, thanks, that worked, and then it closed the issue.
Right? So, uh, there were some back and forth that did not classify us bugs, but I was, like,
figuring out how to use this in real life. So, but then, the, especially given those, like, yellow ones,
like, the conclusion was that, okay, it was a good idea to introduce this, but it's efficient,
right? They did not address, like, what people were really asking for. Right? So, uh, so Lua,
one of the ways that Lua is so minimalistic, and one of the sources of excess is this motto,
like, mechanism, not policies, right? People, so basically the thing that I was trying to do in
which, like, people ask for features, and instead of that, they add features, then allow you to build
the feature or self yourself, right? And that's, like, it's very influence. It's part of not having,
like, the parentheses are not looking, like, Lua is very influenced by skin, like, how bad
something self has said that. So, this whole thing about, like, giving the, you know, giving the
developer the tools for them to develop the, the features that they want. But, uh, when I try to
do that with interfaces, I started getting some, like, feedback, and, like, people starting to do this,
like, child class new instance of the parent classes, this, and that with super with, and that,
and getting to the conclusion, like, okay, the compiler does not type this, does not accept this,
and they go, like, is there a way to type this correctly? Do I have to do inherits inheritance
rust style, right? Because I was giving them, like, something that kind of looked like traits,
really, right? And, and rust has this way of, like, going, now, no, don't do, like, Java style,
OOP, you know, like, do this other thing, right? And I'm featuring here in my slides,
because, like, there's one comment of him saying, like, yeah, like, reading the conversation,
I thought the same, the doc says that interface can be used with object libraries, but do not
demonstrate how, right? Because, uh, uh, uh, uh, and then, like, this same user also tried something
else, and they go, like, polymorphism could also work, although I value my sanity, right?
They were going crazy, trying to fix their problems, like, you, trying really hard to use interfaces,
they were really giving it a shot, right? But they were hitting, like, difficulties there.
And, and I think we have touched on an important point here, because when I release this,
I, uh, I think I oversold the future, by saying, like, oh, you see this, all those
little object models there out there, now you can use them, because I thought that, okay, by,
by putting, like, uh, I'm going back, like, by putting this little macro system that could just
fit to whatever kind of, uh, object class differentiation you could use, like, in different style,
like, okay, one's an attribute, one's a method. Here you could, like, macro your way into accepting
all of that, I thought that would be sufficient. But what I was really thinking was, uh, what I was
really thinking of was the existing object models done in Louis, such as, like, the love to the
object model and things like that, like, objects that are already existed in Louisland, in your
application, that you just wanted to give it types, then you just give it interfaces and everything work.
But, well, these folks here were trying to do, they were trying to build their own new object
systems in Louis, itself, and till itself, they wanted to do the inheritance, they wanted to do,
like, uh, so for that, the interfaces were, uh, were insufficient. But, uh, but at the same time,
we knew that interfaces, even as they are, they were useful. Like, when one of the reason was,
uh, you saw this morning, if you were here, uh, my Google summer code, uh, student, uh, Victor,
who presented here, he did the porting of Lourox, called base to teal, and at one point he was using
light teal stable version, and he kept hitting issues with how to properly type, uh, some
table relationships that I said, like, okay, really need those interfaces. So he switched to the
in development version of, of the compiler and started using interfaces given, you feedback,
how things were working or not, and eventually got, like, got it where was one of the reasons
I'd hit all the way through the port, and I was, as I was adding interfaces, I keep like,
job footing all the time. I started using the interfaces in the compiler itself, and it got,
like, so much better, like, catching things, because otherwise, like, before I had, like, two big
types, like, god-type, like, nodes that's, like, all of the types of nodes of the ST, and another
one called type, which is like, every possible type, with every possible attribute that a
type has, and then I, I broke the type type into a series of, like, a map type and a rate type,
so in that sense, like, okay, so now the compiler actually feels type, because before, you know,
and you're, you're, you're kind of type language, but you're basically only using two types all the time.
So, like, uh, I mean, also I knew that it was, uh, useful in a sense, right? It was a step forward,
but then, what, what we hit there was this distinction between, like, okay, so what do people
want, right? Really? And what I, what do I, the project author want, like, when we're doing
our small project, then we're being happy, like, you know, coding in our free time and, and,
and doing stuff, right? So, I tend to think about this, like, music, and, uh, in music, like, you
often hear, uh, people, like, the standard advice that everyone says, like, oh, you may have to make
the music that you, yourself, want to hear, like, and all of that, but, like, I think that's not
true in practice, like, if everybody makes music, because they want to be heard, right? Like,
because in the end, like, art is a form of communication, and I think, like, free software development
is as well, right? Like, if you, you're, you're right, code, and you put it out there. You want to
have users, right? It's not like, you know, I don't want to just, you know, keep playing my guitar,
locked in my bedroom, and nobody will ever hear it, or, and I don't want to write code that will
never leave my own machine. So, there's a balance to be struck, right? And if you, if you're
go as commercial, then you're going to just focus on what your ping customers want, which is not
even what the majority wants. Like, if you're, like, an open core model or something like that. Like,
if your goal is, like, uh, fame and people are people to like you, then you just cater to what
people want. But then, uh, you might just end up losing interest over time, because it's,
it's not meaningful to you. So, there's, uh, I think in the end, there's this thing about, like, going
for, thinking about what you want and what people want to like. So, what I want is to have fun,
I want to keep, you know, merely, uh, going my way, uh, coding, uh, but I also want people to use it
into like it. Right? So, when going back to all those things that people talked about, like,
when I saw that people wanted, uh, when I saw that people wanted Neil safety, like, what,
what kept in my head was always like, okay, if I had, if I had Neil safety, but then I added,
like, the way I type scripted it, the first turn around and like, okay, now types can't be Neil, but
if you index and array, you get like an array of T, you get a T when you get out of that, but like,
you can index out of bounds and you could still get a Neil. So, the right thing to do with,
to return option, Neil, but then, like, people would have to, like, to test on Neil, like,
every single time, and it would be like super annoying, like, and then, yeah, but then you
cut that corner, but then when it crashes, like you end up in your head, like, having these conversations,
so in the end, was like, what if I do it, and it's not Neil safe enough, like, with one little
Neil escapes and crashes, people's code, and I promise them that it will be Neil safe, right?
And when people wanted objects, I knew that, like, in the new world, there were, like,
seven, different, incompatible object models, and like, and if I gave them an object model,
all right, okay, here's like, new keyword called class, and I'm going to do the set meta-table,
like, automatically, for you, and give you, like, a model that, like, does all of the, the
wiring of inheritance, and everything, like, but a lot of people want a different model,
why to say, okay, this is useless, because it's not useful with, like, the object model that's
already in my lower game engine, and things like that, right? So, I realized that I was always,
escaping from those hard asks, like, because of this game of, like, what if, what if, right?
In the end, this is, like, fear driven design, right? So, like, basically, it was because it was
afraid of, like, people's reactions, right? And sometimes, I actually wanted to do those things
myself, and then I thought, like, okay, what if the reaction is negative, right? So, a few lessons
learned from the stuff that I did for 1224, was that, like, the success of the ART checks thing
with the pragmas, and with, like, maybe someone, like, maybe the ART checks were problematic for
people, but they found that there was a flag there, they, they disabled it, and they continued
with their day, and never bothered me with, like, an issue report, right? So, for the Neil
Safety thing, I could just think of all of those, what ifs, and make them, like, a separate
pragma for each one of them, and let people, like, okay, if they're happy with this part of it,
they can disable it, right? So, maybe, like, there's something that can be done there by adding
gradually, for example. And for objects, maybe users are not that opinionated, like, because I'm
also already, like, inside my head, like, envisioning the flame wars that would happen because
of the wrong object model being picked, and all that. So, an anecdote on that regard was, like,
when it started Lurox, like, it was the Wild West, for there was no package manager for Lurox,
it was the Wild West in terms of, like, how blue a package is where installed. And so, already,
people were opinionated because there were, like, 10 different ways of installing a blue a package,
right? So, the approach that I took with Lurox was to support all of them, right? Okay,
now this is an extensible blue-gain-based system where, like, you can have various
backhands on how to build, and I was just trying to be nice to everybody, I wanted people to
like me, right? And to, like, Lurox, and by extension, like me, I guess. So, but in the end, like, I realized
that I didn't use any of them. So, I made this, like, super silly tiny, out-of-build bundle
into Lurox, which I called the built-in mode. Like, this is the build system if you don't have
a build system. Last time I checked in the thousands and thousands of Lurox packages, like, 80
percent of them used the built-in system. Like, it has become the defective standard way of,
packaging, a blue a module, right? People just, like, they just wanted one that worked, you know,
like, most of the people, they were not in for, like, the flame wars. It just wanted something
that worked. So, yeah. So, maybe, you know, if you put something out there, and if it's useful
for people that will like it, if it's not, they will ignore it, and just keep doing it manually,
the way they're always did. So, yeah. So, that's what happened with Lurox. And one final
fact thought in this regard was that, like, over time, all in all those, like, years since 2019,
the Lurox kept itself as a vault. Like, we now have things like, like, Amy Lurox, Lurox server,
right, that you can put, like, through annotations and comments, like, you, and you get, like,
IDR completion, and, like, annotations for all of the types, and you get, like, a lot of,
what, Teele gives you, right? So, in the end, like, is there even a reason for Teele to exist in
2025, right? And, like, the operator was a bit of foreshadowing, because, like, that you cannot do
with comments, right? So, all of the tooling that exists around Lur, that you can do, like,
cleanters, and Lurox, and comments, and all of that, just like, it's kind of, like, super Mario
Maker, right? Like, it gives you, like, the tools, like, the objects within, like, the way that
the language works, the way Lurox, and it's like, okay, you can arrange Lurox in all sorts of
arbitrary ways and come up with new things, right? So, this is, this is kind of what you're
enjoying. But Teele can be, like, super Mario Wonder, in which, like, we control the universe,
so we can, we can make it be anything we like, right? So, like, if, if this is too niche of a reference,
for you, like, this is, like, Nintendo, like, whenever they're around, now it's their latest,
like, 2D Mario thing, people go, like, what are they going to invent, because, like, since
Super Mario Maker, like, the community has often invented all sorts of levels, right? So,
they basically invented levels that would be impossible to make in Super Mario Maker. Now, now Mario
turns into a huge elephant, and he goes into the background of the screen, and the world works
into layers, and it's, it's really crazy, like, it's, like, it's the craziest platformer
I've ever played. So, and in Teele, we can do that. We can, like, explore syntax and semantics beyond
what Lua is, right? We can make dealing with types more ergonomic, because as soon as it
starts putting option, well, types, you need to have all sorts of little shortcuts, so that you
don't have to be writing, like, if X is nil, like, all the time, right? You can come up with all sorts
of crazy things, and this is just a quick view. Like, none of this exists, and none, I'm not,
I'm promising any of those changes, but this is just, like, throwing ideas, you know,
to the wind of things that would be possible, right? And I'm going to skip, so I don't want you all
to read all of that, but I know you're going to come back in the video and stop and look at
each one of them, but I'm saying, these are no promises, but the idea is just to keep experimenting,
right? And one dilemma out of all of that remains, like, do people even want a minimalist language?
Do I want a minimalist language? Because after all, like, the big thing about Lua is to be
small and simple, but I created Teele because I wanted something else, so did I want a
minimalist language? Like, I have to do a lot of social searching about that as well,
but the main difference is that, like, I see Lua as being for scripting, and I want Teele to be
for, like, applications and libraries, and I think in the end, minimalism is about the conceptual
budget, right? Does it fit in your head, right? So Lua is Lua, until I want it to be Luaish,
and to me being Luaish is, like, have a tiny standard library, it's not like this. Because
if you look back like original Java, it is a tiny language with a huge standard library,
like, you learn Java real fast, but then, like, the world, the JGM world, like, overtakes you.
Right? Lua has, like, no dependency on the questions that we need to switch here.
You write, so this is the last slice. No dependencies, fits in one head, right?
So I'm going to keep experimenting, and the criteria is, does it make the compiler more fun to
write? Does it make more language more fun to use? Does it make the project more fun to
carry, right? And I think this extends also to users who are going to be using the language.
So, unlike, instead of fear driven design, let's go for fun driven design. Thank you.