I think by this time, the Wii had already been out for a bit, which for the record, could play GameCube games.

I’ll try it out later and report back!

the Devil whispered behind the leaves, “It’s pretty, but is it Art?”

The Conundrum Of The Workshops by Rudyard Kipling

Funny, I’ve been having a lot of problems with Mullvad DNS so I just switched to Quad9.

Ignoring my previous beef with PVS-Studio and the crappy AI-generated image…

I think the post is not entirely on the wrong track — dependencies can get pretty ridiculous, but some of the points he (or the AI?) makes are bizarre. I mean, recommending WinAPI over something “non-portable”? I guess there’s always Wine, but I am genuinely curious about what crappy libraries he’s using that are less portable than WinAPI. Also, you could argue most of the points he makes apply to code whether it’s a library or not (for example, compiler compatibility and vulnerability patching). The best point he makes is the one about potential license changes, but even then, the example he gives is softfloat, which went from a hand-written permissive license to BSD, which if anything, made it more permissive.

My best guess is either it’s a crappy AI-written article or his points only apply to whatever niche he specializes in.

So they used a distributed cache for a library that didn’t need to be distributed, switched, and then profiled it for fun? It sounds like they might not even need SQLite, it could be accomplished in a few data structures.

I got a notification two days ago that my extension was taken down. I actually did upgrade it to manifest v3, but I’m not too motivated to republish it. It’s still on the Firefox addon repo, so eh.

Hi there, I don’t think posting to this community will reach the audience you need. First, ads are pretty much universally disliked on Lemmy. it’s a very small community of more developers than consumers. If you want to post your game, it would probably be better to make a post showing a specific game mechanic in your game rather than a shameless ad.

You didn’t mention RetroArch, have you had any issues with that one? I know people have opinions on it, but it’s always worked for me.

So, to start off, I’m someone who does not typically perform well during interviews because of anxiety (but through some miracle has had no issues with employment), so take this response with whatever bias that brings.

I believe this is bad too. You’re still essentially asking a gotcha question, expecting one phrase in your answer and failing the candidate if you don’t hear that phrase. And, in fact, I disagree with the premise. I think the question is defined quite well in the context of programming, given that someone answers with the possibility that there are many ways to hash something and many uses of hashing.

As someone who exclusively shops second-hand the mere existence of this article feels like an omen for prices.

Yes, but this is not typical and the experience is degraded compared to traditional screen readers. There are some that have limited OCR capabilities, but they’re typically used for images without alt text or PDFs that are images.

This is a horrible idea. Accessibility is fairly complicated. Websites are difficult enough to navigate without this.

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.

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.

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.

https://hannesweissteiner.com/pdfs/frost.pdf

That’s the first thing I thought as well. Funny, it wasn’t mentioned in the limitations section.