Sounds like border patrol wiped it, then? Hopefully this case goes nowhere, but it could be years before we find out.

FYI for anyone who depended on old reddit: There are a lot of Redlib instances out there that are being actively updated to the latest instance with fairly high uptime. I use an add-on called LibRedirect which redirects any links from reddit to one of these instances. If Reddit ever hunts down these instances, you can host your own.

Cool stuff. I don't know about ISO but I love these kinds of puzzles. Maybe I'll give it a shot, if it's not too hard. Also love that it's hosted on a Wii.

This has got to be the worst argument I've ever seen.

No way! It was just 25 days ago I saw an article that it could run Half Life 1.

Stack doesn't actually allow indexing, and ElementAt is an extension method implemented by accessing Stack's iterator. My honest recommendation is to not use Stack, even if that's what the book was using. Stacks are not really meant to be traversed. They're meant to be pushed to, and popped (or peeked) from. Each ElementAt call requires O(N) time to retrieve. I recommend switching to List and implementing 'push', 'pop', and 'peek' as such:

// Instead of Push
scopes.Add(item);

// Instead of Peek
int peeked = scopes[^1];

// Instead of Pop
int popped = scopes[^1];
scopes.RemoveAt(scopes.Count - 1);

However, I understand that is a bit of a change. If you'd prefer to keep it as a stack, a simple reversal of the for loop can get the job done.

	// Resolve local variable assignment
	private void ResolveLocal(Expr expr, Token name) {
		// Decrement through scopes
		for (int i = 0; i < scopes.Count; i++) {
			// Pass amount of layers since declaration to interpreter
			if (scopes.ElementAt(i).ContainsKey(name.getLexeme())) {
				interpreter.Resolve(expr, i);
				return;
			}
		}
	}

That's enough to get these scripts running.

>for(var i = 0; i < 10; i = i + 1) { print i;} 
0
1
2
3
4
5
6
7
8
9

>var a = 0; var temp; for(var b= 1; a < 10000; b = temp + b) { print a; temp = a; a = b;}
0
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765

By the way, I noticed that redefining a global variable will crash as well, but a scoped variable will display an error as intended.

Hard bug to spot for sure. It's due to a difference between C# and Java. C#'s Stack.ElementAt() is not the same thing as Java's Stack.elementAt()/Stack.get(). They're actually reversed. Also, ElementAt is a Linq extension method and not a default method like in Java. See the below code/output:

import java.util.Stack;
Stack<Integer> stack = new Stack<Integer>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.elementAt(0));

Output: 1

using System;
using System.Collections.Generic;
using System.Linq;

Stack<int> stack = new();
stack.Push(1);
stack.Push(2);
stack.Push(3);
Console.WriteLine(stack.ElementAt(0));

Output: 3

Hi, I'm not quite sure what you're asking, but .NET debugging is possible inside of VSCodium with the DotRush extension.

This would also work:

while (!(Peek() == '*' && PeekAhead() == '/') && !IsAtEnd())

Years ago, at our company we had React apps sort of following this pattern. But they were single component apps with lots of binded functions and 2000 lines. Not fun.

It worked when their market share was 90%, but I'm not sure it would work today.

I'm not doubting their strategy, but the 'switch' would be a failure simply due to the license.