I like solving puzzles, and I have a knack for programming specifically

“Unlisted” means you can’t find any of them via search or on the creator’s page. But if you still have the URL, you can view them directly

Which includes public playlists other people have created

Python

It’s an amazing scripting language, and my goto for writing automation scripts.

It’s the most lenient of the 3 with dynamic typing and managed memory. It’ll let you learn the basics of reading / writing / running code as well as basic control flow and logic

C is also great to learn, as it teaches you how computers work at a fundamental level, but it’s more stuff to learn up front, and can lead to some very difficult to fix bugs

Java is good as an “application” language. Being memory managed like Python, but statically typed like C. Static typing makes it easier to manage larger code bases

Snake milk

Snilk

Stormlight Archive also has a magic similar to this (Lashings)

The wind would make it rotate

That’s how you end up with a 200lb missile smashing your guts out

I’m not aware of any class of problem that humans can solve that we don’t think are solvable by sufficiently large computers. That is a really good point…hrmmm

My conjecture is that some “super Turing” calculation is required for consciousness to arise. But that super Turing calculation might not be necessary for anything else like logic, balance, visual processing, etc

However, if the brain is capable of something super Turing, I also don’t see why that property wouldn’t translate to super Turing “higher order” brain functions like logic…

I don’t think the distinction between “arbitrarily large” memory and “infinitely large” memory here matters

Also, Turing Completeness is measuring the “class” of problems a computer can solve (eg, the Halting Problem)

I conjecture that whatever the brain is doing to achieve consciousness is a fundamentally different operation, one that a Turing Complete machine cannot perform, mathematically

Also also, quantum computers (at least as i understand them, which is, not very well) are still Turing Complete. They just use analog properties of quantum wave functions as computational components

I suspect Turing Complete machines (all computers) are not capable of producing consciousness

If that were the case, then theoretically a game of Magic the Gathering could experience consciousness (or similar physical systems that can emulate a Turing Machine)

Lox

Once i have a solid implementation, I wanna morph it into a custom scripting language for generating diagrams (a la graphviz or mermaid js)

https://github.com/Lightfire228/lightweaver

I literally just wrote this a few hours ago (line 55)

IIRC, kernel level anti cheat works for linux. It’s at the company’s discretion if they enable support for Linux clients

If you’re not already blinded by the accretion disk

Or torn apart from spaghettification

Or have millions of years pass in the rest of the universe from time dilation being that close

Waydroid doesn’t intend on supporting it. It’s a piece of code that checks for evidence of “tampering” (such as an unlocked bootloader, or root access), and sends those bits of data off to Google’s servers for verification

It’s antithetical to Waydroid and device freedom, and is used by banking apps for “security” reasons, as well as media apps for piracy reasons

And is a massive pain for anyone who root’s their devices

Never make things more “impressive”

Make them more comprehensible

Reduce the cognitive load required to understand and reason about a piece of code. Honestly, the more you can express complicated ideas simply, the more impressive you are

I did this once

I was generating a large fake dataset that had to make sense in certain ways. I created a neat thing in C# where you could index a hashmap by the type of model it stored, and it would give you the collection storing that data.

This made obtaining resources for generation trivial

However, it made figuring out the order i needed to generate things an effing nightmare

Of note, a lot of these resource “Pools” depended on other resource Pools, and often times, adding a new Pool dependency to a generator meant more time fiddling with the Pool standup code

• if something feels too “heavy”, like it’s doing xml formatting, file manips, a db insert, and making coffee, all in a single class or function

Separate out those “concerns”, into their own object/interface, and pass them into the class / function at invocation (Dependency Injection)

• use “if guards” and early returns to bail from a function, instead of wrapping the func body with an if

public Value? Func(String arg) {
  if (arg.IsEmpty()) {
    return null;
  }
  
  if (this.Bar == null) {
    return null;
  }

  // ...
  return new Value();


  /// instead of

  if (!arg.IsEmpty) {
    if (this.Bar != null) {
      // ...
      return new Value();
    }
  }
return null;
}

• if it’s not in git / SVC, add it as is. Create a “refactor” branch, and liberally use commits

• Treat it like a decompilation

Figure out what something does, and rename it (with a stupidly verbose name, if you have to). Use the IDE refactor tools to rename all instances of that identifier

• Take a function, figure out what it does, and refactor it in a way that makes sense to you

• Use the editor’s diff mode to compare duplicate code, extract out anything different into a variable or callback, and combine the code into a function call. Vscode’s “select for compare” and “compare with selected” are useful for this

• Track what you’re doing / keep notes in something like Obsidian. You can use [[Wikilinks]] syntax to link between notes, which lets you build a graph structure using your notes as nodes

• be cognizant of “Side Effects”

For example, a function or property, or class might be invoked using Reflection, via a string literal (or even worse, a constructed string). And renaming it can cause a reflective invocation somewhere else random to fail

Or function or operator overloading/overiding doing something bizarre

Or two tightly coupled objects that mutate each other, and expect certain unstated invariants to be held (like, foo() can only be called once, or thingyA.len() must equal thingyB.len()

• write tests if you can, either using a testing framework or custom Python scripts

You can use these to more thoroughly compare behavior between the original and a refactor

What about Play Integrity / Safetynet?