Noulith: A new programming language by the current Advent of Code leader

Same thing as programmers making tools; if you know you have a defined set of inputs and outputs that you need to use over and over, it might make sense to write your own functions, methods, classes, macros and programs. Taking that one step further, it might then morph into a full blown custom programming language. Domain specific languages are after all fairly common in many domains.

Small correction: hyper-neutrino is a code-golfer and user of Vyxal, but the creator of Vyxal is: https://github.com/Lyxal

* Advent of code is about solving puzzles.

* Making a programming language is like solving a puzzle.

* People that like solving puzzles like puzzles of all kinds, so the likelihood of a top advent of code solver to also have worked in the "puzzle" of making a programming language is big.

Feels pretty logical to me :-)

That means they got a plenty of free time for both the AoC and their language :)

hey that's me in 7th. that language you're looking at is a short lived project i made when i was 12 lol. it's actually the source of my username, i didn't name it after myself but the other way around. anyway yeah it's crap and barely turing complete and definitely NOT what i use for aoc by any stretch.

> Is making your own programming language more common than I realized?

yep it's just that

Some armchair philosophy here. I think languages are fundamentally related to how we think about, process, and express ideas. When you spend a lot of time doing something, you naturally come up with the words to express complex and abstract ideas, which lets you process information faster. These competitive programmers have the experience to realize certain syntax, patterns, common functions better helps them solve the problems they usually encounter, so they build these DSLs to serve that purpose.

I think it's just very common. When I was in high school, I built my own C compiler just to learn how things work under the hood.

I'd assume that it's similar for others in that their programming languages aren't up to date or practically usable, but more like cool side-effects of their learning journey.

Leijurv isn't using Kitteh2 for AoC (YouTube videos indicate python). I think it was just a project.

Building a compiler is usually a part of Computer Science, so most people with a CS degree will technically have some own programming language (although probably a very limited and bad one).

AoC problems often benefit from knowledge of lexers, parsers, and other text processing gymnastics.

People who’ve made compilers and interpreters are both attracted to the problem solving element of AoC and good at solving those problems.

Beyond that, making your own compiler or language is fun — more people should try it.

These are great starting points:

https://craftinginterpreters.com/

https://compilerbook.com/

I think it's quite common for competitive programmers and code golfers to have their own language, often inspired by APL. They often do not require any ecosystem as they are supposed to only solve puzzles, so it's really easy to develop them.

I think AoC isn't that far removed from code golfing, and a lot of people have custom languages for code golfing.

"same with the 7th place[^3]. "

No, that's not the Nim[0].

[0] https://github.com/nim-lang/Nim

what's with the carets [^0] instead of [0] in your citations?

This year, I also started to develop a language (with a simple syntax) from scratch (in C) to solve the puzzles. It is a lot of work. So, I quit after having solved three puzzles. I did it in a kind of literary programming style using MarkDownC (https://github.com/FransFaase/IParse/blob/master/README.md#m...). You can see the page with the code at: https://github.com/FransFaase/AdventOfCode2022/blob/main/Lan...

My theory: (Competitive) programming speed is largely a function of how intimately you know your chosen set of tools and standard libraries. Time spent reading docs is "wasted" time.

If you've written your own language, assuming it's a decent one, then:

a) It has all the tools you need to be productive.

b) You know exactly how it works and what the APIs are (assuming the implementation details are still fresh in your memory).

c) The features are tailored to exactly how you like to use them, personally.

A language made to win hacking competitions prioritize speed and power as in solving a problem fast, rather then readability, debugging, performance, etc.

I've done AoC using my own language before. As a task it's at a sweet spot for finding weaknesses in the language/library/implementation: real and varied enough to exercise your system, small chunks of work, lots of code to compare yours to, with fun and competitive juices.

The first time I did it it forced me to fix some major problems. My language would still be a handicap for me now, albeit a comfy one.

fwiw: https://github.com/darius/cant/tree/master/examples/advent-o... (haven't done this year's so far)

Being good at parsing is most of what you need to be a top AoC contender, so there's a strong connection there.

On a sidenote, I've had a good time reformatting input as python expressions and using eval()

Making your own programming language is not that hard. It's understandable to think that it is, because large, common languages have millions of lines of code and hundreds of thousands of commits authored over decades. But don't compare yourself to them - just making a scrappy language to fit your precise problem domain can be done in a couple of thousand lines of code and a couple of weeks. It's also super fun! (I've done it before...)

Hey! hyper-neutrino here - I notice you've already clarified but yes, Vyxal is originally made by code-golf user Lyxal and not me; I've contributed minimally to it but I would definitely recommend checking it out as it's a great project and goes a lot more in-depth and is way more organized than what I've done :) hence why I've pinned it to my profile.

I do have my own programming languages though; my best one so far is proton[^0] though it's pretty buggy because I wrote it in high school before I took the uni-level CS classes that taught things like language design and how to make actual parsers.

[^0]: https://github.com/hyper-neutrino/proton

Including winning 2021 and 2020! I'd guess that exclusively using a new programming language that you recently invented is actually an impediment to speed, though apparently not a significant enough one.

More exactly winning 2019, 2020, 2021, and runner up 2018, which seems to be the first year participating.

By the looks of it right now, Betaveros will win 2022 too. One could say that Betaveros dominates AoC.

Insane in the best possible meaning of the word. Man, that is so cool.

In my opinion AOC is a very good example for "if all you have is a hammer". For AOC you don't need to write a program that finds a solution for any possible input, you need a calculator to compute the solution for your input. This is such a calculator, and a very nice one.

Suggestion: Flip the assignment operator. You keep writing an expression left to right, but then you have to scroll all the way back to the left to make a variable. This could be streamlined by making it e. g. "EXPR -> VAR_NAME" instead of "*VAR_NAME EXPR".

Why don't you make a Show HN submission? I'd upvote you. :)

> const doesn't count because you can't initialize it with a runtime-computed value

In what language? C's const is an unmodifiable runtime value for example, as is Zig's. Go is one language that I can think of where const is compile-time though.

I would guess because when you're doing a hacky thing, it's convenient to go back and make a change like "x = something with x" rather than updating all occurrences.

Source: I do that all the time when trying to solve AoC problems :)

Because you cannot have loops in an immutable universe? Sure, you can map functions, but sometimes loops are fun too.

I like this idea. I think I've considered adding immutable variables, but haven't prioritized them because other things I wanted to work on have a better expressiveness or bug-catching ability to effort ratio. Plus I haven't thought of a good syntax for them. But I might eventually get around to it.

or a way to get a k or g implimenation.

I thought the leaderboard was dominated by automated GPT-chat bots.

Did they get banned or couldn’t they keep up with the puzzles?

I think it takes a lot more than a language, no matter how efficient to get top 10 in AoC - its more about being able to parse the problem exceptionally quickly, or rather recognise practically from memory the class of problem that the day is asking for and be halfway through coding it before you have even finalised the specifics.

I managed to get 47th on one of the days once... and that was after solving it in under a minute.

Would you happen to have a link to your solutions (Github, Gitlab, wherever)?

Agreed. I don’t mind dynamic typing at all, particularly when facilities exist to establish contracts around what the data you’re passing around looks like. But I don’t think this is a brilliant solution to Python’s problems. Python has issues, don’t get me wrong, but it’s a very very mature language without a lot of WTF moments. On the flip side, a brand new language with this level of freedom means you really need to sit down and grok everything from the inventors perspective before you can be proficient. You need to absorb the entire language for it to work. Meanwhile, and I’m hesitant to beat this drum, a lisp like Clojure is not at all confusing or unclear. The syntax might be hard to grok initially, and the short function names or departure to literal functional programming might throw you off, but after that you realize the air is crisp. The language and stdlib are small and relatively old for a reason - the ecosystem fosters this. You can do and build anything without fuss. It’s wonderful.

I mean that's probably because it's specifically geared towards exercises like this. Languages built for advent of code will probably prioritize stuffing as much syntactic sugar as possible rather than writing maintainable code

Your criticisms are valid, but only if you're approaching it from the perspective of using it for a full-fledged project.

More likely use cases are quick scripts you wanna write or little thought experiments you wanna try out. For that, it's likely a great choice of language

Author here. FWIW I 100% agree with your assessment. This would be a horrible choice for anything resembling production code and I hope nobody considers it. I'm not really even sure I'd recommend anybody other than me use the language for anything; there are a lot of decisions informed by how I, specifically, think about and write code. For me, this language works well when I want to write scripts that are <100 lines or so, and for that alone I think it's achieved its purpose. I think of it as a "home-cooked" programming language, a la <https://www.robinsloan.com/notes/home-cooked-app/>.

Disclaimer: entirely off the cuff

Although the creator demonstrates this with `*` and `+` I could imagine this being useful within a set of higher level operators (functions)

eg. perhaps you want an argument of (infix) `map` to evaluate before `map` itself

Or more generally, you might have a bunch of scalar operators which you'd like to have higher precedence than collection operators which should act on the results

Hi, author here. I'll probably go into this in more detail in a blog post later, but the short reason for runtime precedences (briefly discussed much further down in the README) is that I wanted to be able to write chained comparisons like `x < y < z` without privileging comparison operators in the syntax, so `less_than := <; x less_than y less_than z` also has to work. This means that you can never resolve the structure of a chain of binary operators while parsing, so you have to wait until runtime. The fact that precedence is mutable at runtime is not at all important, but given the above decision, I thought I might as well go the full mile. (Also, it's funny :)

I'm the author but not the OP. Thanks!

I'm not sure I follow the question about infix notation and precedence, but: Trains of identifiers like `a b c d e f g` are always parsed as `b`, `d`, `f` being infix binary operators; their precedences are looked up at runtime to decide how that expression evaluates. Explicit function calls and indexing always bind more tightly, and operands in those trains can contain either; an expression like `a(arg) b c(arg1, arg2) d e[i] f g[j:k]` has the same binary operators as before. But operators are only single identifiers and don't contain function calls, so `a b (c)` is still the binary operator `b` with arguments `a` and `(c)`.

"Sets" are just dictionaries with set elements as the keys and null as every value. This makes sense because you want testing for set membership to be fast like locating a key in a dictionary and because, like in Python, iterating over a dictionary iterates over its keys.

We also already have `.+` for prepending a list element to a list and `+.` for appending. (These are the analogues of Scala's `+:` and `:+`.)

I expect a single individual can move with more agility which is faster for the relatively small-scopes problems AoC prevents.

> competitive programming teams trying to dominate the most visible event

What fantasy world is this? :D

Competitive programming teams, afaik, exist in the context of universities and they want to win ACM-ICPC, that's pretty much it. Otherwise, competitive programming is largely a solo affair.

In an event that yields no prize whatsoever, winning is just for bragging rights. There are no bragging rights in winning as a team against solo competitors.

Also, you only have one problem per night and AoC problems are too easy for it to make sense to have a team collaborating. The only thing a team would do is take the minimum solution time of their participants.

AoC is too easy. There's no benefit to more than one person.

They most likely don't care... :)

Also FWIW most software you use has 5k+ line source files in it.

i would really love when ai replaces cp...