landr0id

>While we are many missing language features away from this being the case, the noalias case is also magic descended upon box itself, with no user code ever having access to it.

I'm not sure why the author thinks there's magic behind Box. Box is not a special case of `noalias`. Run this snippet with miri and you'll see the same issue: https://play.rust-lang.org/?version=stable&mode=debug&editio...

You don't see an assertion failure though because... dun dun dun it's UB.

`Box<T>` _does_ have an expectation that its inner pointer is not aliased to another Box (even if used for readonly operations). See: https://github.com/rust-lang/miri/issues/1800#issuecomment-8...)

oops, typo that I can no longer edit: it rendres the same as it does on the original Xbox*

You may have missed this (from the GitHub repo):

>You do not need a CPU upgraded console to use this patch and having one does not provide any additional performance gains that I've been able to measure during testing.

And this:

>This provided a 10% increase in transfer speeds for consoles running the stock IDE cable and up to a 300% increase (theoretically, the actual transfer speeds depend greatly on the size of data being transferred) for consoles with an upgraded IDE cable.

And this (again from the GitHub repo):

>If your console has 128MB of RAM this patch will utilize the extra RAM available which will enable use of 720p and 1080i video modes as well as increase the size of in-memory caches for textures and geometry. The size increase for the texture and geometry caches will significantly reduce pop-in issues to the point of being almost non-existent.

For just 480p you can overclock the GPU on a stock console and use a different IDE cable. I think the remark about the SSD was unintentionally misleading -- perhaps he did mean the combo of 80pin + SSD though.

It does not require an overclocked CPU (he states that the CPU was not the bottleneck), and the increased RAM is only required if you want resolutions of 720p or higher.

I relayed the feedback though, he might update the blog post to make these points more explicit.

>Halo 2 can run at higher resolutions on a 360, so clarifying that this was a modding project on the original Xbox is helpful.

This isn't true. It renders exactly the same as it does on the Xbox 360 but the scaler chip handles the higher resolutions.

Grimdoomer wrote the article but doom is a different person -- and he's not exactly anonymous. I'm not sure what the other commentator was implying.

relevant: https://www.vice.com/en/article/7x4zza/heres-why-the-trees-o...

It says in the article that the idea behind this implementation is that if the tag is swapped it breaks the authentication since the glue is involved in authenticating. NFC/RFID chips can just be swapped from a real product to a fake one as-is.

>What prevents somebody from scanning it and reconstructing the position of the metal pieces?

You're talking about very, very small pieces of metal whose position/orientation is not deterministic when laying the glue and that information is combined with the tag itself to present some kind of challenge response.

>As I'm not seeing them having completely unique stories

Not sure if I'm reading this as you intended, but 404 broke multiple interesting stories first including the one about the Russian with no ticket or passport who ended up in LA.

I’m just stating my opinion that I find these abbreviations annoying, yes. They are so unintuitive that unless someone explicitly calls out what it’s abbreviating, you probably wouldn’t pick up on it (e.g. the MDN page for Accessibility) and just leaves people confused (like me!). I suspect there’s a reason AccessKit isn’t named `a11yKit`

i18n has been around for ever and makes sense since in code it’s a bit long. Then k8s, which never made sense to me. I don’t know if it’s appropriate to call it a trend, but I’ve seen people doing it more frequently.

The irony with this example is people with screen readers will hear something like “aEleveny” and it looks like “ally”.

> a11y

I apologize for this being so besides the point of your post, but I hate this trend so much.

I used Slint recently and don’t think it’s quite ready for me. It doesn’t support recursive types in the DSL, so trees have to be represented as a flat array. It’s also not possible to combine certain AST elements like an `if` and `for` loop.

The LSP extension for VSCode seemed to have some stability issues as well.

I ended up rewriting the project using egui and found it pretty pleasant. With this said I hope slint succeeds!

I know somebody who was recently drugged and had their iPhone stolen (amongst other things) while on a trip in New Orleans. While he has no recollection of the night, this may have mitigated the damage they were able to cause and the trouble he had to go through to recover his Apple ID.

I doubt the thieves would physically travel to his home for the phone, but I suspect that this will lead to blackmailing scenarios where the thieves exfil risqué or compromising content and threaten to send it to sensitive contacts if you don't unlock the phone the next day.

I don't use LaTeX for anything these days but Typst popped up recently and seems like a decent alternative: https://github.com/typst/typst

> spotify paid snoop dog 40k for 1B streams.

Poor example. If I remember correctly it was a song he had a feature on and there were about a dozen people credited on the track.

Post author here. Thanks to the folks who read through my rambling. There was another trick I discovered a couple days after writing this blog post while trying to fix a file that was decompiling with just empty output. The code pattern that tripped it up was something like the following:

    SOME_VALUE = {value: key for (key, value) in Foo.__dict__.iteritems() }

Which at a bytecode level expands to something like:

    def <dictcomp>(input):
      result = {}
      for (key, value) in input:
        result[value] = key
      return result

    SOME_VALUE = <dictcomp>(Foo.__dict__.iteritems())

The name `<dictcomp>` is intentional here. Decompilers (or at least uncompyle) relies on the function name to figure out what composition syntax the function is for (or a lambda, or generator). The python compiler emits `<dictcom>`, `<setcomp>`, `<listcomp>`, `<genexpr>`, and `<lambda>` depending on the type of function. The obfuscator renamed this function of course and causes the decompiler choke on a whole file if this appears at a module level.

The game developers also reached out to me and others after seeing this post appear on the /r/WorldofWarships subreddit. They want to understand why we would need to introspect these files for mod creation or data mining.

I already explained some of this in the post, but at a mod level the API docs are _really_ bad and actually no longer exist since the developers migrated away from a standard forum to Discord for all comms and killed the forum. For ModAPIv2 which is heavily restricted to pre-approved mod developers there are no docs at all!

Additionally, they rely on a community-created tool for rendering replays to an MP4 for their tournament match recaps: https://github.com/WoWs-Builder-Team/minimap_renderer. The replay format is entirely undocumented and relies on data mined from this tool and other resources for parsing some data structures.

There are a _ton_ of community-developed resources that have only been made possible through reverse engineering of some shape that are critical for understanding the game. I do appreciate them reaching out for hopefully a positive dialog.

This is a terrible experience for people who desire to sit on a couch with a controller. People specifically use devices that spoof their keyboard and mouse a controller so they can get in queues with controller players and retain auto aim. Some games allow native keyboard and mouse support, but then they’re queued with KB/mouse players.

> -ftrivial-auto-var-init=pattern

Would be nice if this was zero instead of pattern.

I paid for whatever the premium version that lifts such restrictions is called. I'm fairly confident that I messaged everyone that matched and if the conversation died I would unmatch to clean things up.

>Anthony couldn’t think of anything that might have gotten his account flagged. Regardless, Hinge didn’t offer an explanation for his experience.

It's been a while since I've been on Hinge, but Hinge is not like Tinder in terms of edgy/risque conversation, and I played every conversation with a match safe. I woke up one morning and was banned. They say you can appeal, but this seems like mostly something to make you feel like there's a possible recourse.

What I gathered from Reddit is that it's actually rather easy to get banned by simply not talking to people. There were a few times where I wouldn't message someone right away from not having a good ice breaker, I was busy, or the conversation just went nowhere and people would unmatch. When you unmatch with someone it asks if you'd like to report them as well. Since Hinge is meant to be a more serious dating platform, not talking to people can be seen as not taking the platform seriously and trying to hook up or something and if this happens enough times it seems Hinge will flag your account.

Former Microsoft employee here who occasionally had reason to work with the emulation team. It’s truly a thing of wonder and I hope they do a public talk on it someday. There are so many crazy tricks they’ve done that deserve recognition.

I don't think it ever included actual source code, but .NET IL is just so rich that it made it extremely trivial to decompile, no?

I tried Zellij a while ago (year+?) and wasn’t a huge fan. After some major updates I tried it again and it’s become my daily driver.

Great application and I’m looking forward to seeing the plugin ecosystem grow. Thanks to the maintainers and contributors for their work.

Not necessarily. The conversation with the Apollo dev was about the missed opportunity cost of having the user on the official platform. The $20m/year number was referring to opportunity cost, not the actual cost.

To me that unpacks to a mix of lost potential value on having the user on the official client for data harvesting + advertising purposes + having full control over user experience, and subtly trying to get rid of 3rd party clients without just shutting the APIs down.

With this model someone just develops a website that passively collects usernames, performs the calculation, and maps usernames to hashed values.

Quick summary:

- Multiple Reddit users have reported both AM4 and AM5 chips that are dying with a bulge on the CPU and a burn mark (video covering an AM4 failure here: https://www.reddit.com/r/Amd/comments/12xxg91/der8auer_i_mis...

- GamersNexus bought a couple of these failed motherboards/processors from Reddit users to do an investigation

- The core issue seems to be over-voltage with some folks believing it's related to AMD's EXPO being turned on, but I don't think there's been any confirmation

- ASUS and Gigabyte have both removed older versions of their BIOS updates

- ASUS has released a statement to Der8aur saying that their recent BIOS update has new voltage protections: https://i.imgur.com/pM358j6.jpg

>The crazy thing he mentioned is that if there was zero compression, the latest COD games genuinely had over 1 terabyte of uncompressed assets.

I think what this shows is there should be smart delivery of assets. Before installing perhaps you should be able to choose your graphical fidelity and only download assets related to that fidelity level and below.

This makes manifest building and delivery more complicated, and probably UX too, but I'm sure it's a problem that the infra/marketplace provider (Valve, Epic, Microsoft, Sony, etc.) could solve and make easy for devs.

Sort of a tangent but I used Ghidra last week to help a coworker figure out where some function was called by looking at the callee tree to it. He was investigating a crash reported by a user that seemed impossible to hit as the function was never called. After about 10m we figured out that the code had been recently refactored and the build I had locally was enough out of date to still have the buggy function call.

I mean it’s fairly obvious. You can do this through build.rs files as well.

There was talk about trying to compile proc macros to WASM and run them sandboxed in the compiler. Not sure what happened to that RFC (by dtolnay?)

Yes, which was kind of a result of people making a fuss about this a year or two ago iirc.