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?

Yes, and no.

If the password is stored properly (hashed and salted), then a high entropy PW will make it nearly impossible for your PW to be extracted from a database dump / data leak

On the other end, if the PW is stored as plain-text, a high entropy PW is useless.

In between, a weak hash algorithm or no salt, a high entropy PW still makes it much harder to extract, but it depends

In general, 2FA is more secure, since it combines 2 different methods of authentication.

• something you know: password
• something you have: the 2FA token (usually on a phone)

This protects the service (as well as the user) against a broader range of attacks. Such as

• password reuse (which nearly everyone does)
  • this is particularly bad, because you’re increasing the chance that a weakly designed system will have it’s data stolen, your reused PW and username included
• phising attempts
  • somewhat
• low entropy passwords
• replay attacks
  • since 2FA tokens are usually time bases (TOTP), they expire after a few minutes and can’t be reused if an attacker manages to intercept one

Among others

According to the article, they used human teeth from cadavers

Ah, ok

He’s satire

I just assumed he was another one of those McDojo idiots

1. If you’re in this situation, you’ve got about a 95% chance of being boned, regardless of what training you have
2. The fuck is that dude doing wearing a coral belt

• Neo

  • Cat 1
  • squeak toy

• Jaune

  • Cat 2
  • Jaunnie boy

• Raven

  • Cat 3
  • wildchild
  • chaos goblin

My brain doesn’t fully boot until like 10pm

I cannot control it. Life would be a lot easier if i could

I vaguely remember from Japanese class that China’s name means “middle country”

But i dunno about that “go” character specifically. It might have a different meaning in this context?

The yeast of thoughts and mind

globglogabgalab

I like Hoppscotch

To be fair

I didn’t notice that either

Install MSEdgeRedirect to solve this problem.

I also recommend O&O Shut Up 10 and StartAllBack

Me: Why go through all that trouble, just install Linux

Alternatively you would switch to Linux.

Welp

Imo, it’s nice to see tools written in a memory safe systems language

Especially if you use a lot of them. More utility, less attack surface

It can be useful if you want a different desktop layout for different use cases

I set up a Personal activity, and a Work activity, with different backgrounds and different apps pinned to the taskbar. That helps maintain a “virtual” separation of work and personal life, and helps me not screw off on discord as much

Well, it would if i actually used it