joshAg

that (edit: the way you were taught) sounds like an altogether awful way to learn any hard science

Your issue with physics but not with math reminds me a little of Hume's law. The difference that has always made that difference "make sense" to me is that math rules, even the axiom we use, are entirely chosen by the people using them, but the rules of physics are only useful if they match/predict what happens in the real world. For math we get to pick the ones that happen to be useful at a given time for a given problem (my go-to example of "it's all made up and the points don't matter" is why 1 isn't considered prime). For physics we're constrained to pick what best describes the real world. It probably helped that nearly all the physics course I had in high school/university had lab components focused on experimentally validating those rules/using those rules to predict results.

nifty. do you happen to have (or could you take) a picture of your actual journal, too, though?

may the Sun never set

If you're feeling nice, randomize whose time remains stable (to keep things fair), keep the organizer's time stable, or pick the time that minimizes the number of participants who will have the meeting time change.

If you're feeling mean, randomize whose time remains stable (to make it hard to predict), move the meeting for the organizer, pick the time that maximizes the number of participants who will have the meeting time change, or split the difference and move everyone. Meeting was at 10 AM for Alice and 9 AM for Bob, but now it can be at either 11 AM for Alice and 9 AM for Bob or 10 AM for Alice and 8 AM for Bob? Now the meeting is at 10:30 AM for Alice and 8:30 AM for Bob.

They mean using the AI to do the import things and the higher structure for them, not removing tedium. It's like using a calculator for math school/home-work designed to teach multiplication, which requires no transcription or putting into context. The tool isn't removing tedium. It's removing the very thing they're supposed to be learning.

And my question is, in the context of learning something, how in the world is having the AI do the thing you're supposed to be learning enticing unless you don't actually care about learning the thing

Why do you think you didn't do similar when you were a student? We've seen this exact issue with other technology before: calculators for math; typewriters and then word processors for writing assignments; audio books for literacy. In those cases we've collectively realized there's a benefit in getting the manual skill and understanding how to use it before shortcutting things with the technology, even if most of the time you'll just end up using the technology. My best guess is that for most people in those classes who failed because of ai use, they don't care about the understanding (usually) required to get a good grade, they just care about the grade itself and the doors that opens for them.

Is that how you want to build a company or society on. Resentment?

I think this misunderstands their goals. They don't care how society/a company is built. All they care about is that they are the one building it and that they are at the top of the hierarchy.

Just like with the startups and tech companies they built, they see speed as a critical advantage so that they can be the first-mover and establish a moat. Long-term viability and health is a distant secondary or even tertiary concern. If the panopticon and some weirdly neofeudal technofacist society can be built faster than something more egalitarian, then that neofeudal technofacist society is - from their perspective - better and that is what they will bias towards and build.

FWIW, it's a little better on the thinkpad side, even today: https://www.thinkwiki.org/wiki/Category:Models

If they want dell, though, they want dell. I'd say give them a budget and have them send you a SKU that fits :P

It's not crazy at all. That's what conglomerates do. GE literally built trains and electricity until 2021 when the train unit got spun off.

Yeah, ok, fine.

The bread book is easier to read than das kapital, and the manifesto is far too simple.

torment nexus creators are shocked, appalled even, to discover that people desire to use it to torment others at nearby nexus

God, i am so glad to see these guys succeeding. The sun may have burned out, but the sky is still bright thanks to them. May they be so successful that i can eventually buy workstation versions of their minicomputers, sort of like how they made CoaL for triton.

just wanted to let you know that this comment is the only reason why i'm using vs code again after about 9 months of not using it at all.

please don't ditch timezones.

https://qntm.org/continuous

please don't ditch timezones.

https://qntm.org/abolish

at least one of the pilots did. according to the preliminary report, the switches were only in the cutoff position for 10 seconds before being switched back to the run position and the engines started to spin up again

so just to confirm, this HN submission [ 1] should have linked to this pdf of the paper [2] and put the article [3] that is the current link for the post as a comment?

  [1]: https://news.ycombinator.com/item?id=44381297
  [2]: https://arxiv.org/pdf/2506.19244
  [3]: https://www.quantamagazine.org/a-new-pyramid-like-shape-always-lands-the-same-side-up-20250625/

We built something similar for the managed DB we use, but i think it's a mistake to autogenerate the migration scripts instead of autogenerating the schema from the migration. Things like changing an enum, adding a nonnull column that shouldn't have a default to an existing table that already has data in it, and migrating data from one representation to another (eg, 'oh hey, we definitely shouldn't have made our users table have an fname and an lname field. let's change to full_name and preferred_name') are easily done in a migration script but hard, if not impossible, to infer from just schema changes.

What are side-effects but undocumented arguments and returns?

Firstly, you want to ensure your functions are pure with respect to input. That is to say, they might reference a configuration or context object that is passed to them as an argument, but they'll never reference some global object/variable.

So then the docker image inside some docker registry? Both the image and the registry are values in the config/context argument at the least. Maybe they're their own separate arguments depending on whether you prefer a single big object argument or a bunch of smaller more primitive arguments.

So then the pure function that expects the docker image to exist in some registry is no longer

  Int -> Int

  String -> String -> Int -> Int

  String -> String -> String -> String -> Int -> Int

  data Registry { 
    user :: String,
    password :: String,
    url :: String
  }

  Registry -> String -> Int

  data Foo { 
    reg:: Registry, 
    image :: String
  }

  Foo -> Int -> Int

PS: sorry if i got the haskell typing wrong. I don't know haskell so that's the result of what i could cobble together from googling about haskell type syntax

It's not meaningless, the author just doesn't like it. Open-source and source available were always meant to be watered-down versions of the FSF's free software specifically to be more palatable to businesses. That's not a bug and it's not even a feature. It's the freaking mission statement.

The aviation industry doesn't usually reduce incidents down to a single proximate or ultimate cause like that, but instead notes every decision/event that contributed to the incident occurring. And then they usually spend time on how they can reduce the likelihood of such an event reoccurring at every single point in that chain. It appears that the coast guard plane lined up on the runway to prepare for takeoff instead of holding short of the runway as instructed and the JAL pilots did not see that their runway was not actually clear until it was too late to avoid a collision (if they saw the other plane at all).

From the JAL plane's perspective, automation is only as good as the sensors and logic which would be checking for if a runway is actually clear. Regardless of whether extant solutions are better than humans right now or will be better in the future, those solutions will still have a same failure mode as humans, which is suddenly realizing a runway that appeared to be clear actually isn't clear when it is too late to abort.

From the coast guard plane's perspective and from the controller perspective, automation and warnings might have been able to alert or prevent, however, automation can't just be thrown around as a solution without deep knowledge of the system and environment in which it will work. The main reason for this is ensuring that the transition between automated-control and human-control is clearly evident to the humans involved, that it occurs with enough time for the human to actually be able to avert a problem, and that the human is actually ready to take control. If the automated system silently disengages, a plane with permission to take off from a runway will instead just sit on the runway because the pilot assumes the automation will begin takeoff as expected, which brings us right back to a plane on the runway when it shouldn't be there and a landing plane not seeing it until it is too late. It is actually possible to land a plane purely with automation (military drones do it all the time), however that isn't done on commercial aircraft, because the constraints are so tight that if the automation were to fail for any reason there is a large chance the human pilot would be unable to prevent a crash even when perfectly monitoring the system (and perfect monitoring can't be assumed).

There's actually a legal reason for tacking on anyone who is plausibly liable. The basic idea is to sue everyone in a single case and let the court sort out actual liability for each party as part of that single case.

Say the lawsuit is originally against just Holman Fleet Leasing and FedEx is the one legally liable (Maybe FedEx is the one that is doing something naughty. Maybe there's some contractual language around Fedex assuming all legal liabilities for the vehicles sold.). You're going to spend a bunch of time in court arguing with Holman about if they're even the right party to sue, and your case is either going to get thrown out or you're going to lose. Meanwhile, the statute of limitations is still ticking, so if it takes a long enough time to adjudicate the case against Holman, you won't even be able to refile the same case with the correct respondent. Oops. but if the statute of limitations miraculously hasn't run out yet, that's not even considering the possibility that the kind of person who would roll back an odometer would also have a punishingly short document retention policy, so all the documents that still existed at the time you filed against Holman have long since been shredded and destroyed, so your discovery in the new case against Fedex is going to be a single email saying "yeah, we don't have anything going back that far. Oops again.

Now consider the lawsuit filed initially against both Holman and Fedex. Assuming your list of respondents is complete, the case isn't going to get thrown out because you sued the wrong person. Liability will still be adjudicated (and the case amended to drop respondents as the proper liability holder gets determined), but now you don't need to worry about the statute of limitations running out as you wait for the determination of liability against the first respondent. And the document retention clock starts with that lawsuit and covers the time where you're just determining who hold liability, so now they can't delete those documents even if they other wise would be. Both of them are now going to be legally required to retain all the stuff you list in discovery for the duration of at least their involvement in the case. Sure, they could destroy those records anyway, but that sort of thing is regularly used to infer guilt of the respondent with the worst possible inferences when it's destroyed in violation of discovery.

Why are acquisitions legal?

It'd take at least semester of public policy, a semester of economics, a semester of history, and a semester of legal studies to adequately answer that.

The shorter answer is that nonnatutal persons and natural persons have the same rights to do what they want with their property, barring very specific exemptions. One of those exemptions is monopolies, but (and add this to the list of shit Ronald fucking Reagan and the university of chicago screwed up, too) in the 1980s US anti-monopoly enforcement switched from focusing on ensuring a competitive marketplace to focusing on ensuring economic efficiency and consumer welfare, so it became much much much easier to merge and acquire competitors.

The range is of values, not their representation in bits, which can be mapped in any order. You could specify that the bit representation for 0 was 0x1234 and the bit representation for 1 was 0x1134 and proceeded accordingly and the range of values for those 16 bits could still independently be [-32768, 32767] or [0, 65535] or [65536, 131071] if you wanted.

We know the signed int they're talking about can't be the standard 1's complement because its stated range of values is [-32768, 32767]. If the representation were 1's complement the range would be [-32767, 32767] to accommodate the -0. It could be some modified form of 1's complement where they redefine the -0 to actually be -32768, but that's not 1's complement anymore.

".... i can't. No one can. It's a mathematical impossibility as a general solution for at least 2 separate reasons.

The first issue is that we're taking 64 bits of data and trying to squeeze them into 16 bits. Now, sure it's not that bad, because we have the sign bit and NANs and infinities, but even if you toss away the exponent entirely, that's still 53 bits of mantissa to squeeze into 16 bits of int.

The second issue is all the values not directly expressible as an integer, either because they're infinity, NAN, too big, too small, or fractional.

The only way we can overcome these issues is to decide what exactly we mean by "converts", because while we might not _like_ it, casting to an int64 and then masking off our 16 most favorite bits of the 64 available is a stable conversion. That might be silly, but it brings up a valid question. What is our conversion algorithm?

Maybe by "convert" we meant map from the smallest float to the smallest int and then the next smallest float to the next smallest int, and then either wrapping around or just pegging the rest to the int16.max.

Or maybe we meant from the biggest float to the biggest int and so on doing the inverse of the previous. Those are two very different results.

And we haven't even considered whether to throw on NAN or infinity or what to do with -0 for both those cases.

Or maybe we meant translate from the float value to the nearest representable integer? We'd have a lot of stuff mapping to int16.max and int16.min, and we'd still have to decide how to handle infinity, NAN, and -0, but still possible.

Basically, until we know the rough conversion function, we can't even know if NAN, infinity and -0 are special cases and we can't even know if clipping will be an edge case or not. There's lots of conversions where we can happily wrap around on ourself and there are no edge cases, and there's lots of conversions where we have edge cases, but we can clip or wrap, and there's lots of conversions where we have edge cases and clipping/wrapping."

With 16-bit unsigned integers, you can store anything from 0 to 65,535. If you use the first bit to store a sign (positive/negative) and your 16-bit signed integer now covers everything from -32,768 to +32,767 (only 15 bits left for the actual number). Anything bigger than these values and you’ve run out of bits.

That's, oh man, that's not how they're stored or how you should think of it. Don't think of it that way because if you think "oh 1 bit for sign" that implies the number representation has both a +0 and a -0 (which is the case for ieee 754 floats) that are bitwise different in at least the sign bit, which isn't the case for signed ints. Plus, if you have that double zero that comes from dedicating a bit to sign, then you can't represent 2^15 or -2^15, because you are instead representing -0 and +0. Except, you can represent -2^15, or -32,768, by their own prose. So there's either more than just 15 bits for negative numbers or there's not actually a "sign bit."

Like, ok, sure, you don't want to explain the intricacies of 2's complement for this, but don't say there's a sign bit. Explain signed ints as a shifting the range of possible values to include negative and positive values. Something like

With 16-bit unsigned integers, you can store anything from 0 to 65,535. If you shift that range down so that 0 is in the middle of the range of values instead of the minimum and your 16-bit signed integer now covers everything from -32,768 to +32,767. Anything outside the range of these values and you’ve run out of bits.

One important note, though, is that the backup and multidevice requires their cloud servers* so the threat model is a little different. They've got a blog on how they do the cloud backup**, but since you need a password it either needs to be something you can remember or be stored in a password vault that doesn't rely on getting a 2fa code from authy for access.

* for the paranoid, there's a mode where it doesn't backup to the cloud, which makes it function the same as google auth, but that does defeat a lot of authy's benefits.

** https://authy.com/blog/how-the-authy-two-factor-backups-work...

Hey, so this is admittedly monday morning quarterbacking, but in the future, you can definitely consider moving from Google Auth to Twillio's authy [1]. It lets you move devices and all your secrets come with you (it's also got other cool features, but the one that is killer IMO is the ability to migrate from device to device).

https://authy.com/

Sounds like they're finding out why most companies won't fuck around with outbidding competitors for talented employees just so that they can't work for a competitor.