However...

Long long ago I worked for a major NAS vendor. We had customers with huge NAS farms [1] and extremely valuable data. We were, I imagine, very exposed from a reputation or even legal standpoint. Drive testing and certification was A Very Big Deal. Our test suites frequently found fatal firmware bugs, and we had to very closely track the fw versions in customer installations. From a purely technical viewpoint there's no way we wanted customers to bring their own drives.

[1] Some monster servers had tripple-digit GBs of storage, or even a TB! (#getoffmylawn)

Posts so far:

[1] https://funcall.blogspot.com/2025/03/vibe-coding-in-common-l...

[2] https://funcall.blogspot.com/2025/03/vibe-coding-in-common-l...

[3] https://funcall.blogspot.com/2025/03/ai-silliness.html

[4] https://funcall.blogspot.com/2025/03/vibed-into-non-function...

Comments URL: https://news.ycombinator.com/item?id=43507717

Points: 2

# Comments: 1

    > I think a new approach might be to ignore the specifics of the old system, implement a new system

1. This is an old IBM COBOL system. That means EBCDIC, not UTF or even ASCII.

1.A Fine, we'll mass-convert all the old data from EBCDIC to UTF. Done.

1.A.1 Which EBCDIC character set? There are multiple variants. Often based on nationality. Which ones are in use? Can you depend on all records in a dataset using the same one (hint: no.) Can you depend on all fields in a particular record using the same one? (hint: no.) Can you depend on all records using the same one for a particular field? (hint...) Can you depend on any sane method for figuring out what a particular field in a particular record in a particular dataset is using? Nope nope nope.

1.A.2 Looking at program A, you find it reads data from source B and merges it with source C. Source B, once upon a time, was from a region with lots of French names, and used code page 279 ('94 French). Except for those using 274 (old Belgium). And one really ancient set of data with what appears to be a custom code set only used by two parishes. Program A muddles through well enough to match up names with C, at least well enough for programs D, E, and F.

1.A.3 But it's not good enough for program G (when handling the Wednesday set of batches). G has to cross-reference the broken output from A with H to figure out what's what.

1.B You have now changed the output. It works for D and F, but now E is broken, and all the adhoc, painstakingly hand-crafted workarounds in G are completely clueless.

1.C Oh, and there's consumer J that wasn't properly documented, you don't know exists, and handles renewals for 60-70 year old pensioners who will be very vocal when their licenses are bungled.

2. Speaking of birth years, here's a mishmash of 2-, 4-, and even 3-digit years....

Comments URL: https://news.ycombinator.com/item?id=42679127

Points: 281

# Comments: 102

The "twin paradox" [1] is a prime example. The two twins depart from a common point in time and space, go about their separate travels, and meet again at a common point in space-time. Despite both twins always having the same constant speed of light, one of the twins takes a shorter path through time to get to the meeting point--one twin aged less than the other. In the paradox case, the shorter/longer paths are due to differences in acceleration. But the same thing happens due to differences in gravitation along two paths. (In fact, IIUC, acceleration and gravitational differences are the same thing.)

Just thinking about the math makes my head hurt, but it's apparent that two different photons can have taken very different journeys to reach us. For example, the universe was much denser in the dim past. Old, highly red-shifted photons have spent a lot of time slogging through higher gravitational fields. As a layman, that would suggest to me that, on average, time would have.. moved slower for them?... they would be even older than naive appearances suggest. I don't think the actual experts are naive, so that's been accounted for, or there's confounding factors. But I could also imagine that more chaotic differences, such as supernovas in denser galatic centers vs. the suburbs, or from galaxies embedded in huge filaments, could be hard to calculate.

[1] https://en.wikipedia.org/wiki/Twin_paradox

[1] https://www.swpc.noaa.gov/phenomena/total-electron-content

[2] https://en.wikipedia.org/wiki/Total_electron_content

They're measuring it by looking for phase differences in the received L-band (~2GHz) signals, rather than amplitude. That eliminates lots of noise. And they're looking for a particular pattern, which lets you get way below the noise floor. For example, the signal strength of the GNSS (GPS) signal itself might be -125 dBm, while the noise level is -110 dBm [2]. That means the signal is 10^-12 _milliwatts_, and the noise is about 30 times larger. But by looking for a pattern the receiver gets a 43 dB processing boost, putting the effective signal well above the noise.

[1] https://www.youtube.com/watch?v=BEpZmRPPWFo

[2] https://www.nxp.com/docs/en/brochure/75016740.pdf

What I find interesting is the 4-second delay before igniting the second stage. This is very inefficient compared to immediately igniting it when the first stage burns out. Max-Q (airspeed pressure) issues? 30,000 ft permit ceiling?

Edit: * At 25 sec. it's still going up, so the velocity is decreasing due mainly to gravity, but the rocket is ballistic so the accelerometer is slightly negative due to air friction adding to the gravity deceleration. At about 40 sec. it has reached max altitude and velocity is zero. Accelerometer is still close to zero. Velocity picks up, as shown by barometric altitude curve. Eyeballing it, at about 65 sec. its reached terminal velocity, as shown by barometer curve being pretty flat. Decrease after that is due to decreasing t.v.

EXT (all versions) has a filesystem flag telling the kernel to panic on FS error. In the link, Will Dormann demonstrates inserting a USB key with a malicous image and instantly rebooting the PC.

In this case, the laptop had USB auto-mounting enabled. However, I believe this should apply to any mounts against user-modifiable or -specifiable sources. NFS, FUSE, user namespaces, even local files with "-o loop" option. And the MOUNT(8) man page has this interesting tidbit:

    Since util-linux 2.35, mount does not exit when user permissions are
    inadequate according to libmount’s internal security rules. Instead, it
    drops suid permissions and continues as regular non-root user. This
    behavior supports use-cases where root permissions are not necessary
    (e.g., fuse filesystems, user namespaces, etc).

Comments URL: https://news.ycombinator.com/item?id=42392696

Points: 2

# Comments: 1

[Edit:] All too real scenario: Carrier knows about particular IP addresses and ports used by alert service. Carrier makes provision for separate path for it. Carrier also tries to shave said provisioning to the bone, calculates a worst-case, and adds 5% capacity. Which doesn't get updated when that particular app gets a 6% boost in subscriptions. Back in the old days the traffic management folks would be on top if it, but that's all been outsourced...

* Notification path. IoS at the time was pretty protective of the user's battery, and had specific services you had to use. I imagine there's special treatment now for emergency communications.

* Phone state. How deeply asleep is it? Are there other background apps frequently contacting the mothership? Multiple apps can get their requests batched together, so as to minimize phone wake-ups. You can also benefit from greedy apps--VoIP apps, for example, might be allowed/figured out a hack to allow frequent check-ins, and the other apps might see a latency benefit.

* Garbage carriers. Hopefully emergency alerts have a separate path, but I've noticed my provider (who shall remain nameless but is a three-letter acronym with an ampersand in the middle) sometimes delays SMS messages by tens of minutes. (TBF, in my case there might also be a phone problem [Android], but since nameless provider forced it on me when they went 4G-only they're still getting the blame.)

In your case, my money would be on the carrier. Pushing a notification to all phones in an area can be taxing, and cheaping out on infrastructure is very much a thing.

For docs, your best bet would be to go to the developer sites and pull up the "thou shalt..." rules, particularly regarding network activity, push notification, and permitted background activities. And yeah, Apple was much more dictatorial, for good reasons.

[1] https://www.eevblog.com/forum/beginners/is-there-any-way-to-...

At first everything seemed OK. but when I plugged a monitor into the PI I Was Made To Realize a) the nice 18-volt PS really was high quality, and although it was transformer-isolated its output ground was tied to the wall socket earth, b) monitors also tie HDMI cable ground to earth, and so c) my lash-up now had dueling grounds that were 9V apart.

I finally figured out it was a problem with specific pairs of servers. Server A could talk to C, and D, but would timeout talking to B. The gRPC call just... wouldn't.

One good thing is you do have the source to everything. After much digging through amazingly opaque code, it became clear there was a problem with a feature we didn't even need. If there are multiple sub-channels between servers A and B. gRPC will bundle them into one connection. It also provides protocol-level in-flight flow limits, both for individual sub-channels and the combined A-B bundle. It does it by using "credits". Every time a message is sent from A to B it decrements the available credit limit for the sub-channel, and decrements another limit for the bundle as a whole. When the message is processed by the recipient process then the credit is added back to the sub-channel and bundle limits. Out of credits? Then you'll have to wait.

The problem was that failed transactions were not credited back. Failures included processing time-outs. With time-outs the sub-channel would be terminated, so that wasn't a problem. The issue was with the bundle. The protocol spec was (is?) silent as to who owned the credits for the bundle, and who was responsible for crediting them back in failure cases. The gRPC code for Go, at the time, didn't seem to have been written or maintained by Google's most-experienced team (an intern, maybe?), and this was simply dropped. The result was the bundle got clogged, and A and B couldn't talk. Comm-level backpressure wasn't doing us any good (we needed full app-level), so for several years we'd just patch new Go libraries and disable it.

Some generalities:

Function call: The developer just calls it. Blocks until completion, errors are due to bad parameters or a resource availability problem. They are handled with exceptions or return-code checks. Tests are also simple function calls. Operationally everything is, to borrow a phrase from aviation regarding non-retractable landing gear, "down and welded".

IPC: Architectually, and as a developer, you start worrying about your function as a resource. Is the IPC recipient running? It's possible it's not; that's probably treated as fatal and your code just returns an error to its caller. You're more likely to have a m:n pairing between caller and callee instances, so requests will go into a queue. Your code may still block, but with a timeout, which will be a fatal error. Or you might treat it as a co-routine, with the extra headaches of deferred errors. You probably won't do retries. Testing has some more headaches, with IPC resource initialization and tear-down. You'll have to test queue failures. Operations is also a bit more involved, with an additional resource that needs to be baby-sat, and co-ordinated with multiple consumers.

RPC: IPC headaches, but now you need to worry about lost messages, and messages processed but the acknowledgements were lost. Temporary failures need to be faced and re-tried. You will need to think in terms of "best effort", and continually make decisions about how that is managed. You'll be dealing with issues such as at-least-once delivery vs. at-most-once. Consistency issues will need to be addressed much more than with IPC, and they will be thornier problems. Resource availability awareness will seep into everything; application-level back-pressure measures _should_ be built-in. Treating RPC as simple blocking calls will be a continual temptation; if you or less-enlightened team members subcumb then you'll have all kinds of flaky issues. Emergent, system-wide behavior will rear its ugly head, and it will involve counter-intuitive interactions (such as bigger buffers reducing throughput). Testing now involves three non-trivial parts--your code, the called code, and the communications mechanisms. Operations gets to play with all kinds of fun toys to deploy, monitor, and balance usage.

The reason was safety. If it was orbital, then controlling the re-entry would require a sucessful relight of the engines. If that failed then the re-entry point would depend upon the vagaries of orbital decay from residual atmospheric drag. That's no doubt why today's relight was so brief; they didn't want to significantly alter the reentry point.