mmaniac

The Vita homebrew scene is very mature and surprisingly active. "It's surprisingly easy to hack your 3DS" is a meme for good reason, but it holds even truer for the Vita.

PS1 backwards compatibility on the PS2 has always been a mix of software and hardware. This includes the PS2 slim†.

https://israpps.github.io/PPC-Monitor/docs/Architecture%20Ov...

> The PPC-IOP ASIC, present in SCPH-75xxx and newer PS2 models, features a hybrid hardware and software approach to emulating the MIPS R3000A processor found in the PS1 and 70K or older PS2 models. The hardware portion of this emulation comes in the form of an Auxiliary Processing Unit or APU attached to a PPC 440 core clocked at 440MHz. The software portion comes in the form of the “DECKARD” emulation software.

The PS3 has always used pure software emulation for the PS1.

†Technically only the SCPH-7500x and later slim models feature the PPC-IOP and Deckard. The SCPH-7000x works the same as fat consoles, where the CPU side of PS1 games run natively on bare metal.

Good article, but the most curious part comes in the final footnote. After all that has been said, the final sentences are these:

> If you actually wanted a solution for boys to want to go to college, bring back male-only colleges. Watch college suddenly become really popular for boys again.

Is this resentful sarcasm, or sincere pragmatism? I can't tell.

The thing is... it isn't just another regular register. Reads from the PC are 8 bytes ahead, because that's where the PC is in the pipeline at read time. Branches are PC+8 relative for the same reason.

It's a design choice that makes sense in the classic RISC world where pipeline details are leaked to make implementation simpler. Delay slots in other RISCs work the same way. But it causes a lot of pain as implementations evolve beyond past the original design, and it's why Aarch64 junked a lot of Aarch32's quirks.

I'm not a fan of Rust, but my God, just use Rust instead of this. This is unreadable.

It's transpilers all the way down...

"Compatibility" has a specific meaning in C which isn't the same as what you're describing here. What you're talking about is implicit conversions without narrowing.

Compatibility is essentially about ABI: https://en.cppreference.com/w/c/language/type#Compatible_typ...

The C standard is quite loose about pointer requirements. Conversions between data pointers or between function pointers are allowed, but conversions between each other are not guaranteed. You can read the nitty gritty here: https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf

POSIX defines stricter requirements for pointers than the C standard. All pointers are compatible, so they have the same size and representation, and conversions between function pointers and void* are explicitly allowed.

A good paper, but I think it could have used a little more detail. There was a long, complicated cat & mouse game between hackers and Nintendo, and a lot of that was glossed over to focus on individual exploits.

In particular, there's no mention of Gateway or the MSET exploit they used to get the first foothold in the 3DS ecosystem.

The discussion on arm9loaderhax also doesn't make it clear that the exploitable arm9loader was introduced for the New 3DS as a reaction to previous hacking efforts. The humorousness of it making the console vulnerable to a new and more powerful exploit was explained more clearly in the 3DS hacking talk at 32c3,

Your criticism seems more general than just Python and Haskell. It's really about dynamic and static typing. That's a legitimate debate, but as far as static typing goes, Haskell has one of the best static systems around - and because of that, idiomatic Haskell is unlikely to look like the example you posted.

> It almost never plays out that way in practice. What seems to happen is that after some period of time, people are making good money and they're typically spending all of it, and it becomes really hard to dial that back. If you bought a house or have all sorts of obligations of one sort or another, it may be very difficult.

This just sounds like lifestyle creep. Not everyone suffers from it.

The MiSTer project specifically targets the DE10-Nano board and its Cyclone V FPGA SoC. There isn't a port or similar project available for some better board AFAIK.

FPGA emulation is a niche within a niche and is targeted squarely at enthusiasts. I'm not surprised that you're expected to get your hands a little dirty to get it working.

This has frustrated me too. I've completely avoided using sleep these days, and instead use hibernate.

Bizarrely, Microsoft also wants to hide this option from you too. But it still exists and modern SSDs are extremely fast.

A lot like video game streaming, the appeal of this totally misses me.

The Blitz was an 8 month campaign targeting cities all across Britain. Operation Gomorrah had a comparable death toll within one city over eight days. It sounds like the density of destruction from Gomorrah was a lot greater.

Why are stack sizes generally set so small, anyway? Can demand paging not be used to have a potentially enormous stack without the common case being expensive?

AMD's mobile CPUs have had confusing names since 2022 with the 7000 series, and are now completely bonkers. The completely unnecessary insertion of "AI" into every name, the TDP suffix now an optional prefix, and the extremely poorly justified generation counter starting at 300.

Intel on the other hand were fairly sensible. i7 becomes Ultra 7 and the numbering restarts from 100 (Meteor Lake). That's easy to follow.

Nvidia can't really enter this segment unless Windows on ARM takes off, and they don't want to be the one to put the first foot forward.

If Snapdragon X Elite is a success, you can bet Nvidia will be producing laptop SoCs with passable CPUs and great iGPUs.

Moore's law only talks about transistors - in an IC they should double every 2 years.

3 years after the Apple M1, the M3 increased transistor count from 16 billion to 25 billion. Two years saw the 5950x with 8.3 billion transistors go to the 7950x with 13.1 billion transistors. That's quite not the predicted rate of scaling, but it is respectable.

2x the transistors doesn't mean 2x the performance though. We can make plenty of logic, but the DRAM to feed it remains high latency and the SRAM to hide the latency isn't scaling well either. PHYs are consuming proportionally more silicon too. One might say that Moore's Law isn't dead, but diminishing in relevance.

The line between remaster and remake is a blurry one.

Nier Replicant ver.1.22... isn't officially called either a remake or a remaster, and a convincing case could be made for either. Yet it changes more than Demon's Souls PS5 does.

It is easy to find criticism of Demon's Souls' remaster's art style by entering that term into your favourite search engine. This isn't "considered" true by "almost everybody".

Regardless of any person's opinion on the changes, being substantially different is enough reason that it isn't a suitable substitute for the original.

Wipeout on the Playstation - by defunct developer Psygnosis in Liverpool, England - is well known for having good PAL versions.

I can see how that would be difficult for low level emulation, but does it really matter for HLE?

Retail games running on the PS4 don't care about the PCIe topology, they just use Sony's function call APIs.

The PS4 Pro struggles to run this game at 60fps due to a CPU bottleneck. On the other hand, PS5 runs it remarkably stably at 60fps and even 120fps is decent.

Source: Me and my hacked PS4 Pro and PS5.

That's right. Sonic the Hedgehog on the Mega Drive is the goto example, where even the music runs slower.

As other commentors have pointed out, Japan uses NTSC. PAL is mostly a European thing.

As far as the SNES is concerned, PAL consoles simply letterbox the video and run the game 16.6% slower. Occasionally the game speed is modified to account for the decreased framerate. Super Metroid's engine was sped up so that gameplay was faster frame-by-frame and approximately as fast in wall clock time, but this introduced a number of bugs.

It wasn't until framebuffer based consoles like the Playstation where using the extra lines of PAL signal became common. Game speed was still a common issue until the Dreamcast and PS2 where game speed ceased to be an issue and optional 60Hz support was also common.

People will respond to the incentives that are given to them, regardless of ethics.

The question is, what system would avoid this perverse incentive? A graduate tax would have the same problem. Free tuition shifts the burden to every taxpayer unfairly. Maybe another repayment scheme, but that would disproportionately harm poorer students.

To tell you the truth, I'm not sure what tools a creditor has to pursue a debtor who has left the country in general...

The newer plan 5 loans have lower interest rates... But are only forgiven after 40 years, not 30. On average new graduates will pay more over their lifetimes.

The blame for this system, if one is inclined to blame, can be laid at the feet of Tony Blair's neoliberal New Labour. The decision to begin charging tuition fees was made because of a belief in market economics and privatisation, but also because of that government's stated ambition to get 50% of young adults into universities. Without both factors, I don't believe the system would have mutated into the expensive beast it is today.

This sort of thing is ordinary for consoles without floating point numbers. It's easy to do in software with integers, but sometimes hardware acceleration will use it too.

The SNES and GBA both supported affine transformations, where the elements of the multiplication matrix are fixed point numbers. The Playstation's geometry coprocessor (GTE) used fixed point matrices with quite low 16 bit precision. An emulator feature called PGXP is able to perform these calculations at higher precision.

The killer IMO is the combination of mutability and implicit references. With either immutability or explicit references, the hazards are greatly lessened. In the absence of mutability, there's no observable difference between passing a reference and passing a value. With explicit references, there's always an indication when objects are liable to nonlocally mutate.

Go and C are quite wise to use pass by value and opt-in references. It avoids the programmer's burden of immutability by default while making it more obvious* when to be aware of potential mutation. A programming style incorporating local mutation also comes very naturally, which is simple, practical, and remains easy to reason about.

*Go and Rust would be wiser if they retained -> from C so that this obviousness would remain without having to check type declarations which may even have been inferred.

Python gets hit the worst by this combination. On top of having mutable references everywhere, it also doesn't make a big deal about object identity (unlike e.g. Java) and has a lot of declarative constructs. Which means you get surprising stuff like this.

  >>> foo = [[]] * 10
  >>> foo[0].append("bar")
  >>> foo
  [['bar'], ['bar'], ['bar'], ['bar'], ['bar'], ['bar'], ['bar'], ['bar'], ['bar'], ['bar']]

  >>> def baz(arg = []):
  ...   print(arg)
  ...   arg.append("qux")
  ... 
  >>> baz()
  []
  >>> baz()
  ['qux']