HNHacker News
TopNewBestAskShowJobs

arghwhat

9,034 karma · joined January 12, 2017

no.
submissionscomments
arghwhat··on Apple and SpaceX link up to support Starlink satellite network on iPhones
For remote areas that might still be tens to hundreds of kilometers of poles and fiber just to add coverage to one remote area. Then you move on to the next.

No one wants to do that across all of Alaska or the Australian outback.

arghwhat··on Hard numbers in the Wayland vs. X11 input latency discussion
What you are showing is just a standard color pipeline, which is the bare minimum for color management.

On AMD in particular, the cursor plane must match several aspects of any plane it overlaps with, including transform and color pipeline IIRC.

The AMD SoC in my laptop (much newer than the steam deck) only exposes two overlay planes to share among all 4 display controllers. Intel used to have a single overlay plane per display.

The Raspberry Pi 5 on the other hand intentionally limited the exposed overlay planes to "just" 48, as it can be as many as you have memory for.

You can peek at the reported capabilities of various devices here: https://drmdb.emersion.fr/

arghwhat··on Hard numbers in the Wayland vs. X11 input latency discussion
Well, GPUs from the big players do give a damn as they tend to have surprisingly limited plane count and capabilities. It is often just a single primary, cursor and overlay plane, sometimes the latter is shared across all outputs, and sometimes what the plane can do depends on what the plane it overlaps with is doing.

Mobile chips are as you mention far ahead in this space, with some having outright arbitrary plane counts.

arghwhat··on Google open-sources the Pebble OS
They have had revenue as pebble sold their smartwatches. Acquisition includes liability.

You do not need revenue to be liable though.

arghwhat··on Google open-sources the Pebble OS
You'd be surprised by how much PR specifically targets a certain audience.

Converting a zero-value IP into low impact positive PR has business value. Making MS-DOS sources public falls in the same bucket.

arghwhat··on Hard numbers in the Wayland vs. X11 input latency discussion
Wayland display servers will already be using what is commonly referred to as hardware cursors.

They just use the atomic API to move a cursor or overlay plane, which reflect how the hardware handles things. That the legacy API exposed a specialized cursor API was just a quirk of the design.

Note that planes are a power optimization more than anything else, as it allows e.g. the cursor to move or for decoded video frames to be displayed while GPU's render-related units are powered down. Drawing the cursor move, even though the render task is a rounding error, would require the render-related units to be on.

arghwhat··on Hard numbers in the Wayland vs. X11 input latency discussion
Is it a weakness of the web that HTTP is just a protocol specification?

The "problem" with this in Wayland is that before people 'ran Xorg with GNOME on top", now they just run GNOME the same way they run Chrome or Firefox to use HTTP - it will take time for people to get used to this.

arghwhat··on Hard numbers in the Wayland vs. X11 input latency discussion
This would have to be done by the kernel driver for you GPU. I kind of doubt that it's possible (you're not really scanning out lines anymore with things like Display Stream Compression, partial panel self refresh and weird buffer formats), and doubt even more that kernel devs would consider it worth the maintenance burden...
arghwhat··on Hard numbers in the Wayland vs. X11 input latency discussion
It's not an "argument", it's just a description of what Wayland is. But no, the correct protocol has had copy-paste since day one, and I dont remember there being issues with screensavers.

In the metaphor of a web server and a web browser, Wayland would be the HTTP specification. What you're usually interested in is what server you're running, e.g. GNOME's Mutter, KDE's Kwin, sway, niri, or what client you're running, e.g. Gtk4, Qt6, etc.

arghwhat··on Hard numbers in the Wayland vs. X11 input latency discussion
This is not what Wayland does, it is what a particular display server with Wayland support decided to do.

Second, just to be clear, this only discusses mouse cursors on the desktop - not the content of windows, and in particular not games even if they have cursors. Just the white cursor you browse the Web with.

Anyway, what you refer to is the legacy drm interface that was replaced by the atomic one. The legacy interface is very broken and does not expose new hardware features, but it did indeed handle cursors as its own magical entity.

The atomic API does support tearing updates, but cursor updates are currently rejected in that path as drivers are not ready for that, and at the same time, current consensus is that tearing is toggled on when a particular fullscreen game demands it, and games composite any cursors in their own render pass so they're unaffected. Drivers will probably support this eventually, but it's not meant to be a general solution.

The legacy API could let some hardware swap the cursor position mid-scanout, possibly tearing the cursor, but just because the call is made mid-scanout does not mean that the driver or hardware would do it.

> but it does add an average of 1 more frame latency

If you commit just in time (display servers aim to commit as late as possible), then the delay between the commit and a tearing update made just before the pixels were pushed is dependent on the cursor position - if the cursor is at the first line shown, it makes no difference, if on the last shown, it'll be almost a frame newer.

Averaging cursor positions mean half a frame of extra latency, but with a steady sampling rate instead of rolling shutter.

Proper commit timing is usually the proper solution, and more importantly helps every other aspect of content delivery as well.

arghwhat··on Hard numbers in the Wayland vs. X11 input latency discussion
Display devices (usually part of your GPU) still have "explicit display hardware just for the mouse" in form of cursor planes. Later this has been generalized as overlay planes.

Planes can be updated and repositioned without redrawing the rest of the screen (the regular screen image is on the primary plane), so moving the cursor is just a case of committing the new plane position.

The input latency introduced by GNOME's Mutter (the Wayland server used here) is likely simply a matter of their input sampling and commit timing strategy. Different servers have different strategies and priorities there, which can be good and bad.

Wayland, which is a protocol, is not involved in the process of positioning regular cursors, so this is entirely display server internals and optimization. What happens on the protocol level is allowing clients to set the cursor image, and telling clients where the cursor is.

arghwhat··on Using your Apple device as an access card in unsupported systems
> Sure, there's a long tail of banks/cards that don't support it yet, but I think it's fair to call Apple Pay and Google Pay massively deployed and successful solutions.

Sure, but my point was that Google didn't have an easier time as a result of Apple putting in the legwork - Google was first, neither is done, and others are far behind.

> Absolutely nothing needed to be upgraded in the payment terminals

You need to upgrade to support contactless payments, which was not previously a requirement to accept a payment method and not at all widely rolled out - in Denmark, contactless payments launched a year after Apple Pay released in the US, and that's despite Denmark generally being cashless and far ahead of US on credit card security stuff.

Contactless payment is still not universally supported, so upgrades are still pending.

arghwhat··on I'll think twice before using GitHub Actions again
Of course you can, just specify a container image of your choice and run the same container for testing locally.

However, replicating environmental details is only relevant where the details are known to matter. A lot of effort has been wasted and workflows crippled by the idea that everything must be 100% identical irrespective of actual dependencies and real effects.

arghwhat··on Using eSIMs with devices that only have a physical SIM slot via a 9eSIM SIM car
Chinese iPhone has no eSIM support (they have dual SIM instead), IoT stuff like alarms tend to use SIM slots, LTE/5G routers tend to use SIM, etc.

Until eSIM provisioning for embedded devices is sorted out and popularized there will be plenty of reasons to adapt to a regular SIM.

arghwhat··on I'll think twice before using GitHub Actions again
Azure DevOps specifically has a very broken approach to YAML pipelines, because they effectively took their old graphical pipeline builder and just made a YAML representation of it.

The trick to working with this is that you don't need any of their custom Azure DevOps task types, and can use the shell type (which has a convenient shorthand) just as well as in any other CI environment. Even the installer tasks are redundant - in other CI systems, you either use a container image with what you need, or install stuff at the start, and Azure DevOps works with both of these strategies.

So no, it's neither hard nor impossible, but Microsoft's half-assed approach to maintaining Azure DevOps and overall overcomplicated legacy design makes it a bit hard to realize that doing what their documentation suggests is a bad idea, and that you can use it in a modern way just fine. At least their docs do not recommend that you use the dedicated NPM-type task for `npm install` anymore...

(I could rant for ages about Azure DevOps and how broken and unloved it is from Microsoft's side. From what I can tell, they're just putting in the minimum effort to keep old Enterprise customers that have been there through every rename since Team Foundation Server from jumping ship - maybe just until Github's enterprise side has matured enough? Azure DevOps doesn't even integrate well with Azure, despite its name!)

arghwhat··on I'll think twice before using GitHub Actions again
My "favorite" is when I see people go all in, writing thousands of lines of Jenkins-flavor Groovy that parses JSON build specifications of arbitrary complexity to sort out how to build that particular project.

"But then we can reuse the same pipeline for all our projects!"

arghwhat··on Using your Apple device as an access card in unsupported systems
> The reason Apple Pay actually took longer than Google's solutions is because Apple (presumably) co-developed the payment networks' tokenization solution,

Google Wallet launched with NFC-based mobile payments in 2011. Apple Pay launched in 2014. Neither solution is fully rolled out yet.

Apple's "co-development" was all pre-launch, but not sure how much of this was Apple helping vs. Apple demanding. During this time, Apple demanded secrecy so that only select bank employees would know what was being developed/that it was being made for Apple.

There's an article about what was going down back then: https://archive.nytimes.com/dealbook.nytimes.com/2014/09/11/...

Slow uptake afterwards is a matter of not only every issuer needing to integrate, but also every payment terminal/network needing to be upgraded. Apple in turn likely held back release in a region until enough banks and payment processors had done the legwork.

These services are still rolling out - Google Pay added two more countries last week! Apple Pay came to Egypt last year. Samsung Pay came to Germany in 2020, Denmark, Finland and Norway in 2022 and Saudi Arabia in 2024. Doing anything with the financial sector anywhere is a bloody pain.

arghwhat··on Using your Apple device as an access card in unsupported systems
> A big part of the reason why these Apple Wallet systems have taken so long to appear is because Apple seems to refuse to integrate with any system that isn’t built using secure cryptography.

That's not the issue. Rather, there's an issue of what protocols existing access control systems support, what the iPhone can reasonably expose, and a need for integrating iPhone provisioning into every system, and for the last part, Apple likely hiding this behind some costly MFI certification program.

According to Ubiquiti, Apple Home Key integration strictly requires that the lock, reader and "processing unit" is a single combined device installed on the door. If your architectures splits that into two or three devices, then you'll be turned away at the door. There's numerous of these access key types, with different features and requirements.

Also, just being NFC doesn't automatically make it fit into the box of a smartphone wallet card. For example, take transit cards that use on-card balances to be able to board a bus in intermittent-connectivity areas.

Aliro is an access control standard launching this year which all major players seem on board with. This avoids the integration, certification and gatekeeping headaches.

> Broadly, yes, almost all NFC based access systems are insecure and pretty broken

To clarify, some NFC based systems just use the card ID, use ancient deprecated card types that have been broken for over two decades, or both. If the NXP NFC Reader app says your fob or card is MiFare Classic, then yeah it's in that category.

But higher security solutions also mean no card cloning, so pre-Aliro the vendor would have to go out of their way to get e.g. Apple integration and MFI certification.

arghwhat··on I'll think twice before using GitHub Actions again
> no way of running actions locally

My policy is to never let pipeline DSLs contain any actual logic outside orchestration for the task, relying solely on one-liner build or test commands. If the task is more complicated than a one-liner, make a script for it in the repo to make it a one-liner. Doesn't matter if it's GitHub Actions, Jenkins, Azure DevOps (which has super cursed yaml), etc.

This in turn means that you can do what the pipeline does with a one-liner too, whether manually, from a vscode launch command, a git hook, etc.

This same approach can fix the mess of path-specific validation too - write a regular script (shell, python, JS, whatever you fancy) that checks what has changed and calls the appropriate validation script. The GitHub action is only used to run the script on PR and to prepare the CI container for whatever the script needs, and the same pipeline will always run.

arghwhat··on Hands-On Graphics Without X11
> I feel we lost a lot of this simplicity over the years, but it's "still there" if you don't care about optimal performance.

You lost some simplicity in going "straight to the metal", but at the same time it never really went straight to the metal because things have not actually worked that way for ages, nor do anyone really want to deal with exclusive access.

On the other hand, you can make a window with a shm buffer on your display server, giving you the same drawing simplicity of the old interfaces but without having to deal with fbdev, evdev, exclusive access, etc. - with that in mind, I do not think anything educational was lost.

No harm in playing around though.

arghwhat··on Hands-On Graphics Without X11
These interfaces can be cute to play with, but there's a reason that fbdev is deprecated on Linux - it's not a good interface outside toy examples. wscons may be more powerful, but I don't think it can be used to fully enable modern accelerated display devices, although do correct me if I'm wrong.

Despite some confusion in terminology, modern interfaces also operate on frame buffers, but with an API for switching them out atomically. Likewise, your display server (at least modern ones) just take your client window as a completed frame buffer, and mainly serve to let multiple applications all show their frame buffers without having to worry about what other applications are doing. Frame buffers all the way down, just with support for DMA, atomicity, fancy formats and color spaces, etc.

You can use the appropriate modern APIs to make a single, exclusive graphical application with all the benefits of modern display hardware easily enough. That is, after all, what your display server is. You just don't gain much - just a little bit of saved sideband IPC.

X11 makes it seem like a display server is a complicated thing that has to support drawing and what not, but with alternatives like Wayland, a full screen client buffer is handed off zero-copy from the client application tot he hardware without being looked at.

arghwhat··on Scheduled tasks in ChatGPT
The "old" Apple certainly didn't ship anything quick or on the bleeding edge, nor did they ship the "best" experience. They did, however, have somewhat different priorities than their competitors. They still do to some extent.
arghwhat··on Servo vs. steppers: Speed, Torque and Accuracy [video]
Closed loop is the control method, "servo" describes an assembly of a servo motor and its controls.

Good closed loop stepper controllers are a huge step up (heh) from open loop control, but there's a big difference in characteristics of a stepper motor - which is a very special motor configuration making huge trade-offs specifically to allow repeatable open-loop operation - and the more standard servo motor choices. Because steppers are special you also tend to specifically say "closed loop stepper" rather than considering it a servo.

Be a bit careful with random closed loop controllers though. Cheap ones can be finicky, and poor tuning and broken failure modes is no fun when used in machinery that could injure you, which tends to be where such steppers are installed. Aggressive and erratic movement or randomly entering fault and powering down is quite a lot different from simply losing steps.

arghwhat··on Postgres UUIDv7 and per-back end monotonicity
Relying on an explicitly documented implementation behavior that the specification explicitly describes as an option is not an issue. Especially if the behavior is only relied on in a test, where the worst outcome is a failed testcase that is easily fixed.

Even if the behavior went away, UUIDs unlike serials can always be safely generated directly by the application just as well as they can be generated by the database.

Going straight for that would arguably be the "better" path, and allows mocking PRNG to get sequential IDs.

arghwhat··on Dumping Memory to Bypass BitLocker on Windows 11
True, Microsoft can't be expected to make software that is good for the sake of being good. Maybe they'll consider now Microsoft looks bad on their own - OPAL2.0 on modern drives is quite a different beast than what they pulled out of.

Note that the advantage is still very large - easily 20% and an associated hit to battery life, depending on the specific cipher mode and access pattern. Without AES-NI it just wouldn't be practical to even consider AES-based FDE.

arghwhat··on Dumping Memory to Bypass BitLocker on Windows 11
The inelegant approach increases risk by relying entirely on the OS being sure that the key is never recoverable from memory on clean shutdown, and on the firmware ensuring that all used RAM is sufficiently wiped in all unclean scenarios.

What if Windows forgot to wipe a spot after having relocated a page? What happens if the firmware's boot flow is interrupted by, say, a hardware fault prompt, a low battery prompt, etc.? There's a lot of places where that approach can go wrong.

The key approach is simpler and comparatively bullet proof: If the machine is rebooted, clean or not, the key will be lost and no memory that was previously used will be readable. All it takes is the OS initializing a single CPU feature on boot, with the only downside being that it requires support for a quite modern CPU feature.

arghwhat··on Dumping Memory to Bypass BitLocker on Windows 11
Fair enough, but I'll still hold that wiping all system RAM is a comparatively dumb and slow solution even in this specific scenario. :)
arghwhat··on Dumping Memory to Bypass BitLocker on Windows 11
It was two entirely seperate vulnerabilities.

The Crucial drive did not have any association between the encryption key and the passphrase, making it possible to bypass encryption.

The Samsung drive had an issue where when setting a passphrase, wear leveling could cause the old unprotected key to still exist on a flash bank (not normally accessible) until that bank got reused.

Only one of them is horrible incompetence - the other is bad but fixable and expires on its own after a bit of use.

arghwhat··on Nikon reveals a lens that captures wide and telephoto images simultaneously
The intended output is, in essence, a wide-angle photo but with much greater detail in the center as if that portion had been taken by a telephoto lens and placed on top like smartphones do - but with no offset like smartphones normally deal with.

The processed result would be quite uninteresting to look at: it's a wide-angle photo where the outer portion is much more blurry than the center. Considering the current intended application, the picture probably would probably be pretty mediocre.

This is very specific technology that solves very specific problems (and might one day make its way to smartphones), but not something I'd expect to produce glamor shots right now.

arghwhat··on Dumping Memory to Bypass BitLocker on Windows 11
All SSD's with OPAL are always encrypting your data. "Enabling" the feature just means that you change from a random on-device key to a key encrypted with your passphrase.

(Whenever you wipe the drive through OPAL, you're just overwriting the key.)

← PreviousPage 18 of 34Next →