nyanpasu64

I found that Dolphin uses OS sleeping to run the emulation roughly in sync with wall-clock time, and use a dynamic-rate audio resampler to output sound with a bit of added latency. This has the complication that frame delivery is no longer synchronized with monitor refresh, and requires VRR displays (unlike an actual Wii) for low-latency output. I had a draft PR to loosely couple the sleeps with "frame queuing delay", but it didn't get merged.

In the case of writing an audio synth, I think the usual approach is to "hurry to sleep", but synchronized with the audio device/OS mixer's 2-3 audio buffer periods/pages (rather than visual frames), and asynchronously update the UI. Are you planning to use wall-clock time, or the audio sample clock, as the source of truth for timing?

To this day there are more Windows XP users than Vista, and more Windows 7 users than 8/8.1.

Ironically I've found that lotion is better at cleaning resins/flux off my hands than soap alone.

Are we better off creating diagrams from code (turning text into graphics using layout engines), or code from diagrams (using WYSIWYG editors to interact with a declarative format)?

Unfortunately(?), Transactional NTFS is deprecated and Microsoft claims it may not be available in future versions of Windows.

Haha the pitch modulation noise sounds like LFSR white noise from an 8-bit console...

As I've previously commented (https://news.ycombinator.com/item?id=37236699), this website consists of content copied and translated from other Chinese websites, without permission (I've asked one author). The homepage is pumping out articles much faster than I would expect a person to be able to write them, and I found multiple articles with text stolen and translated from other people's writing, and code stolen verbatim. Flag and move on.

That would be a good idea for file sync and documents, but wouldn't be as effective for RSS readers where the server needs to know the list of URLs to fetch, and terminate the TLS connections itself (unless the client does the fetching and pushes up articles in an encrypted format).

Oh, that reminds me of the Epic Citadel UE3 demo for Android/iOS, ported to asm.js and WebGL (https://www.youtube.com/watch?v=MyAcKgr6mZU)... funny how that turned out, mobile gaming turned into a cesspool of pay-to-win, and WebGL gaming never replaced desktop apps, and the demo doesn't even load anymore (if you try archive.org, it fails to fetch resources over JS XHR). Books last centuries, but digital history can die in merely a decade.

Not to be confused with O3D, Google's rendering engine in early Chrome... https://hn.algolia.com/?q=o3d? Beach demo, https://www.youtube.com/watch?v=uofWfXOzX-g, anyone? ...oh it's just me.

I found a rip of the 3D model and an archived page for the beach demo, but the actual browser plugin was never archived and I don't want to setup decade-old build systems for obsolete browser plugins. How I miss those days...

The scans of the photographs at the end of the article are illegible. I do wonder if the aperture's gradual opening/closing results in Gaussian-like defocus bokeh and tapered-off motion blur (in the presence of defocusing, spatially tapered like a CRT).

What was the poor choice of database on Element (Android or Electron), and how does it increase power usage?

I don't like having my personal workflows dependent on payments or subscription fees, and I don't like rewarding enshittifying corporations deliberately worsening free programs with feature restrictions and manipulative upsell ads (see Windows 10/11, Discord, scummy mobile apps/games, etc.) Re. other areas of life, I will pay (limited) amounts of money for scarce goods (which software isn't), but frankly it's terrifying that you're reliant on unaffordable payments and subscription fees to avoid freezing or starving to death in real life. Given my current (in)ability to hold a job, I don't see a long-term future for myself surviving.

For one thing, Google search ads should not show users a domain different from the domain Google redirects directly to. If a website wants to track clicks, the URL they ask Google to send users to should not live on a different domain than the domain the user sees before clicking. Anything else invites impersonation like this, and makes Google complicit in undetectable phishing.

See previously, gilimp and https://fxtwitter.com/ericlaw/status/1712531148356661494.

> The problem is, a CRT TV draws frames in real time. The Nintendo knows that when it draws a frame, that frame drawing is corresponding with the moving electron beam of the television in real time. In fact, NESdev claims that the photodiodes use have their signal die in as short as 10 scanlines, so the game needs to check more frequently than the 60Hz clock that usually governs an NES game.

Hell, my solar panel (which reacts slower than a photodiode) has its response to green/blue phosphors die in 1-2 480p scanlines (which last half as long as 240p scanlines)! Though if hooked up to a high series resistance, it takes a looot longer for the charge to dissipate.

I suspect the difference in switch-off times between a Zapper and Light Phaser is related to the support circuitry (https://hackaday.io/project/9782-nes-zapper-video-synth-ther..., capacitors? transistors?!) translating the photodiode's signal to the controller pin. Series capacitors will block continuous light, and higher resistances will make a short signal last longer before dissipating.

> This would take a lot of frames to check every single letter if this worked the same way as the Zapper.

You could binary-search to find which letter was shot, though this would obviously fail if the user is moving the light gun between letters. It would probably be more reliable if the lit-up region wasn't just a small box but the entire grid cell.

> But look at what we’ve done here: the Master System is literally reading in-line with the electron beam. This means that for this to work, you really do need an electron beam that moves in sync with the VDP. An LCD just won’t give you that moving dot, no matter how much delay you add.

What's the latency of CRT composite chroma decoding? (EDIT: http://www.hawestv.com/mtv_color/delayline.htm says luma is delayed by 1.3 us to match chroma. Compare to the total scanline duration of 63.7 us, or visible duration of around 51 us.)

How many pixels does that shift the light gun? (1.3 / 51) * 256 px = around 6.5 pixels. It's possible that Master System games compensate for this delay using an empirically tuned horizontal offset.

Can you have the runtime run a job every second, to trim thread stack depths and return memory to the kernel (whatever was meant by https://www.youtube.com/watch?v=kPR8h4-qZdk&t=1150s) while holding a FFI mutex (or a sharded one), and have every C function call first lock the mutex and expand the stack to the necessary depth?

Would snmalloc (https://news.ycombinator.com/item?id=37851210) help with scalable threading or not? It claims to be better at allocating memory on a producer and freeing on a consumer thread, and "Freeing memory in a different thread to initially allocated it, does not take any locks and instead uses a novel message passing scheme to return the memory to the original allocator, where it is recycled. This enables 1000s of remote deallocations to be performed with only a single atomic operation enabling great scaling with core count."

Dealing with similar issues myself, what health issues did you discover and what do you do to cope?

I've largely left Reddit since they backstabbed third-party apps and frontends, and seized subreddits and banned moderators protesting their decision. Checking https://subredditstats.com, many subreddits (ranging from smaller ones like CRTgaming, to larger ones like funny) have had comment volume drop off by 75-90% in July 2023 with no sign of recovering. So assuming Reddit isn't throttling/blocking subredditstats from viewing comments (and making itself look bad), I'd say people are leaving Reddit, but unfortunately I'm not sure if any of the community-run alternatives are as popular as Reddit is now (or was before the user exodus).

I had a USB cable with a reversible A plug, but after a few months/years it would stop charging (because the pins either wouldn't make contact with the A socket, or the wires snapped off the pins).

I broke the ring on a M.2 Wi-Fi card, but installed the cable onto it anyway. I think the part I bent off will probably rip off and get stuck in the cable the next time I take the connector off the card. Here's hoping I'll never have to do that...

Phosphors are funny little things. In my Gateway VX720 (like Diamond Pro 710, not the other VX720), the blue and green phosphors light up the fastest and decay to near-zero the fastest (100-200 us), but have a long dim phosphor trail that persists for hundreds of milliseconds. Red starts up slower and decays slower (hundreds of us), but reaches zero brightness well before the next frame.

OLEDs without strobing, on the other hand, have a full frame of brightness persistence (and LCDs have slow color changes on top of that).

Super Mario World and many other SNES (and later) games spends two frames after a controller jump input sending unchanged frames on-screen, before showing a frame where the player is jumping (tested in slow-motion camera). Emulators (and possibly FPGAs) can use run-ahead to skip past one or more of these "no change" frames, reducing input latency to match or surpass console latency (https://github.com/higan-emu/emulation-articles/tree/master/...).

Another strategy is to delay polling input computing the next frame until the end of the previous frame being drawn (RetroArch frame delay). This does not rely on the game not responding immediately to controller input, but is more prone to dropping frames if your CPU gets occupied and can't run your emulator for a few milliseconds.

It is possible to compute and display images in near-real-time over HDMI, but this technique is quite niche (https://blurbusters.com/blur-busters-lagless-raster-follower...).

What plastics are still safe to use? Polycarbonate is made from phthalates (BPA and others), an unknown portion of HDPE contains PFOAs, PET plastic bottles leach antimony when hot...

I self-host a LAN-only Nitter instance for personal use. In the last few months of Elon trying to lock out third-party clients, it's gone from automatically acquiring tokens, to tweet access breaking and coming back and eventually breaking again, then only showing "top tweets" for users rather than full post history, to having to log into Twitter in a browser and extract some cookies/headers using Developer Tools (and failing to show user post history because they tried using RSS feeds that got pulled). The latest development is the use of "guest tokens" (https://github.com/zedeus/nitter/pull/985) that you have to create and install by hand (running a Node script) because Nitter hasn't automated the process yet. This works well for viewing all tweets, but hasn't been merged to the master branch yet (but nitter.net and the AUR nitter-git package are already using it).

I heard Unreal Nanite built a job queue system on compute threads (https://www.youtube.com/watch?v=eviSykqSUUw&t=1611s), would that help with your use case or not?

My experience is that I was unable to debug Maestral (a Python program) crashing in native Cocoa bindings in LLDB, because the interpreter did not allow itself to be debugged. Mozilla says Firefox acts the same way at https://firefox-source-docs.mozilla.org/contributing/debuggi.... It's possible there's some workaround I'm not aware of, but I ended up disabling SIP just like every non-macOS computer I own.

I disable SIP because I don't want to use an OS where I cannot debug programs which did not consent to be debugged. macOS makes it impossible to inspect failure states I encounter in normal usage (like I can on Linux with debuginfod enabled, or Windows with .pdb files) without first rebuilding the program in debug mode.

Another factor is that "take X when you wake up Monday and Y when you go to bed Monday" falls apart if you stay up past midnight (then you're taking the second Monday pills on Tuesday), then if you wake up later at 10 PM Monday and go to bed Tuesday afternoon (pretty soon you're taking both of Monday's pills on Tuesday and need to skip taking a day in your pill tracker), whereas recording the last time you took a pill allows you to space them approximately 8 hours apart regardless of the date/time you last took one.

I find that day-based medication organizers don't work when I have a non-24-hour sleep schedule. I ended up writing down dates and times of doses on a paper notebook, because pill planner apps aren't built for non-24 schedules either, the one I found on F-Droid didn't record times which are useful for optimally spacing medication, and I kept forgetting to either take or record medications in my locked phone.