A 10-year journey, condensed (0m31s)

Surya opens by framing the talk as a decade of his life — from six to sixteen — and warns the audience that a lot has to be left out to fit thirty minutes.

"I always dreamed of giving a talk here, but I never thought it would actually happen, but here I am today"

"this journey is from when I was six to now when I'm 16, and that spans 10 years"

"quite a lot can happen in 10 years, and it's pretty hard to condense that all down into a 30-minute talk"

Learning to code at six, home-educated (1m33s)

At six he asked his dad to teach him to code, and being home-educated meant the curriculum was whatever his parents already knew — which gave him both freedom and time other children didn't have.

"for basically my whole life, I've been home-educated"

"the skills I decide to learn need to be things that my parents already know"

"I have a lot more free time than if I had to go to school five days a week"

Potio.nz: a Little Alchemy clone (2m33s)

His first project, still online ten years later, was a re-implementation of the Little Alchemy video game where he could control which elements combined into what — his dad wrote the code while talking him through it.

"I liked this game, but some of the combinations, or lack thereof, were just a bit unsatisfying to me"

"the great thing about this is that I control all the combinations and I can customise it however I want"

"my dad wrote the code, but we talked through it together, and he explained to me what the different bits did"

Teaching as a way to learn (4m37s)

His dad started programming classes for him and other children, and helping the other kids turned out to be the best way to deepen his own understanding.

"teaching, I've always found, is a really good way to learn something better yourself"

"in order to be able to explain something to someone, you need to understand it really well"

"different people think in different ways, so you often end up adapting your explanation"

FFconf at eight, and Async (5m40s)

In 2017, aged eight, he came to FFconf for the first time — too short to be visible in the photo, picked up by his mum at lunchtime — and started attending Async, the monthly meet-up his dad has run since 2009.

"I dunno how many of the talks I really understood that first time, I was still learning to code myself, let alone understanding other people's code"

"at lunchtime, my mom came and picked me up and took me home"

"I didn't really notice any of the other attendees' mothers coming to pick them up"

Minecraft datapacks: an esoteric language (8m47s)

A deep dive into Minecraft's command system led him to datapacks, an oddly constrained scripting environment with global-only variables and no function arguments — an esoteric language hidden inside a video game.

"all variables are global, there's no scope, and functions don't have arguments or return values"

"it's like a virtual machine, in a virtual machine, in a virtual machine"

"you could argue that datapacks are an esoteric programming language"

Becoming Gears, and finding a community (11m23s)

He started a YouTube channel under the handle Gears to share his datapacks, competed in datapack jams, started a podcast and gave an in-game conference talk — and found a community of people who shared his niche.

"internet safety tells us not to [use your real name], and also, it wouldn't really be cool enough for a Minecraft datapack YouTube channel"

"the strict deadline gave me lots of motivation to work on the features and come up with a solution within the time limit"

"I was able to find a community of people who shared the same niche interests with me"

Learning lots of languages (15m28s)

The conventional advice is don't be a jack-of-all-trades, but learning many languages — even shallowly — gave him different mental paradigms to draw from when solving problems.

"a Java developer thinks of everything in terms of classes. A Haskell developer thinks in terms of functions and monads"

"a Java developer who knows Haskell might still come up with a largely class-based solution... but they can integrate some of the tricks and patterns they learned from Haskell"

"there's only two types of languages, the ones that everyone complains about and the ones that nobody uses"

Building his own languages (17m37s)

Three attempts: Language using parser combinators (scrapped — terrible error messages), Test Language with a proper lexer and recursive-descent parser, and Libra, a designed-from-scratch ideal language written in Go.

"parser combinators are a bit like regular expressions... if it fails at any point, it backtracks and tries something else"

"by the time you've backtracked and tried all your options, you've lost all the context about where the original error was"

"I called it Libra after the Zodiac sign for scales, because I wanted it to be a balance between all the best features of the programming languages that I knew"

A first attempt at WebKit (23m48s)

Inspired by an FFconf after-party conversation, he tried to contribute to WebKit — but a 90-minute clone, millions of lines of C++ and no entry point meant he fell at the first hurdle.

"after about an hour and a half... yeah, that's literally how long it takes to clone WebKit"

"I never really got started. I fell at the first hurdle and never ended up contributing anything"

"I still had the idea of contributing to open-source in the back of my head"

Contributing to Rust, briefly (25m23s)

A second open-source attempt — the Rust compiler, since he knew the language — got him one PR merged, but the process felt stressful rather than satisfying.

"it turned out not to be that easy, because it took me quite a long time to figure out my way around the code base"

"I didn't really feel satisfied with my contribution. I mostly felt relieved that it was over"

"the whole process was quite stressful to me trying to understand how this massive code base worked"

Discovering Gleam (26m57s)

Gleam — a functional, statically typed language with friendly syntax and no monad-jargon — caught his eye on its 1.0 release, and the small, well-documented compiler was the perfect open-source entry point.

"unlike a lot of functional programming languages, it has really nice familiar syntax to anyone who's written, for example, JavaScript"

"the documentation doesn't use any of that... it explains everything in really simple terms"

"Gleam must have a compiler. And also it's a relatively new project, so theoretically the compiler would be a lot smaller than something more mature like Rust"

Joining the Gleam core team (29m32s)

This time the contribution experience was the opposite — Louis (Gleam's creator) was welcoming, the community was friendly, and an invitation to join the core team followed.

"Louis... is just a really nice guy, so the review process went super smoothly"

"the Gleam community is really nice. It's one of the most friendly and welcoming communities I found on the internet"

"he asked me if I wanted to join the core team. It was an unpaid position at the time, but I thought it would be a good experience"

Start with something useless (32m39s)

The moral: start with something useless that you enjoy — a copy of an existing game, a Minecraft datapack, a language only you will use — and eventually it turns into something useful that other people benefit from.

"the moral of my story is that you should start by making something useless that you enjoy"

"a copy of an existing game, a Minecraft datapack, a language that only you are going to use"

"eventually it will turn into something useful that everyone can benefit from"