kuroko VS tailspin-v0

(kuroko)[https://github.com/kuroko-lang/kuroko] is basically Python, but C

Kuroko: Dialect of Python with explicit variable declaration and block scoping, with a lightweight and easy-to-embed bytecode compiler and interpreter.

I would say Kuroko makes more sense ;-P

Kuroko 1.3.0 gets a release candidate. Lots of big things since 1.2.5, like optimized method invocation, more operator overloads, better support for f-string expressions (format specs, =, faster constructions), a long type with my own bigint implementation (this was the last thing I was still regularly opening Python repls for, so a huge personal win). I also fixed a bunch of little things that have been nagging me, like the compiler can now compile expressions directly, which allowed me to remove the kludge that made the repl work previously. The WASM web repl also got some love with a port of the core of Hiwire from Pyodide, giving a very straightforward interface between JS and Kuroko in a browser - and I rebuilt the web IDE on it. I've also been working on a new compiler, which will hopefully form the basis of 2.0 - and this might be the last 1.x release (though I expect at least a few 1.3.x bug fix releases).

In case it's not clear, PonyOS is a joke reskin of my serious OS project, ToaruOS. PonyOS gets a new release every April 1st. All of the libraries and applications in ToaruOS are in-house things I built myself - the whole OS is "built from scratch". PonyOS adds ponysay, which is an external app originally written in Python - and in previous releases of PonyOS I shipped the Python version alongside a port of Python 3.6. This release, though, comes with a port to my own language, Kuroko, which is a dialect of Python - a lot of what went into building the PonyOS release this year was getting ponysay to work well.

Did this year's Advent of Code in Kuroko which sussed out some bugs and missing functionality. Better hashing for tuples, more builtins and methods on standard classes for improved compatibility with Python, general build cleanups. In the later problems, most suffering was caused by the GC, so I'd like to put more thought into collection strategies going forward.

Is it me you're looking for?

I eventually tend to do all days in Tailspin. The ones I have done so far are in directories ending in "tt" (the others are in Pyret, just to get a feel for it) https://github.com/tobega/aoc2023/tree/main

As a general tip, it is often helpful to first try to think of how you would like to represent the data in your program. Then you need to parse the data into that structure. I'd recommend you to look at a PEG-parser, for example. Or if you like, look at my Tailspin programming language which has a very visual parser syntax and also very visual ways of creating data structures (if that should happen to be your mental affinity). Look at my day1 for example. Or if you're more mathematical, maybe a functional language (I also did day1 in Pyret)

My Tailspin language is based on processing streams of values, you might want to look at it https://github.com/tobega/tailspin-v0

Many people had trouble with the day 7 problem. Paradoxically, good developers probably had more trouble. Here some of the difficulties are explained and implementations are provided in imperative, functional and OO styles, written in the Tailspin programming language.

I test almost entirely from my language, that way the tests are independent of the implementation. Currently the tests are implemented in java because that fits the interpreter implementation https://github.com/tobega/tailspin-v0/tree/master/test/tailspin/samples

Finished off the implementation of typed and offset array indices in Tailspin

I ended up enabling left recursion in Tailspin's composer (parser) syntax. Much cleaner calculator example now.

I think it's possible that Tailspin might be suitable for you.

I think gradual typing is definitely something worth exploring more. I thought it was a shame when Dart abandoned that path. Have you seen Shen ? I guess my small offering, Tailspin, is currently evolving to gradual typing as well.