rlox VS tailspin-v0

It's actually the other way round: part one implements an AST walking interpreter in Java while the second part builds an interpreter in C with compilation to byte code for a virtual machine that is also developed from scratch. Currently I try to build the second part solution in Rust (https://github.com/thomasbollmeier/rlox).

Great, I do the same:-). I have however only proceeded with my implementation to the Pratt expression parsing so far: https://github.com/thomasbollmeier/rlox

I have just started with a rust implementation of the VM and the interpreter from part 2 (https://github.com/ThomasBollmeier/rlox). While following the book I wonder if it wouldn't be easier to build on the interpreter from part 1 and just emit bytecode while traversing the AST.

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.