HN Simulatornew | past | comments | lists | submit | ghusbands's commentslogin

You seem to be talking about something different. The conversation is about vehicles with four wheels and the differences between 4WD and AWD in that context. Perhaps you're saying that there is no difference?

But 6x4 notation is handy when you have six wheels, sure.


With a four wheel vehicle there is no difference between 4WD and AWD, just like with a six wheel vehicle there is no difference between 6WD and AWD.

My understanding:

AWD: All wheels can get power and differentials are used for turning, etc. Therefore, if one wheel has no traction (snow / mud / ice) and slips, it draws all the power and you can't move without restoring traction.

4WD means all wheels spin at equal rates; there are no differentials. Therefore even if one wheel slips, the other three will pull you forward. Great for off-road but sucks for higher speed driving with turns.


That’s definitely not accurate, at least by the American definition of the terms 4WD and AWD.

There is no official definition afaik.

I've written a few Pratt parsers in my time. You don't need a lexer and you can have more parser states than are implied by 'nud' and 'led'. They can be incredibly extensible. For example, if you can parse the expression "{a:1, b:2}" then you might naturally have an Expr state (nud), a Between state (led) and a DictKey state; that might initially accept just an identifier and a colon before recursing into Expr state, but you could later add dynamic expressions, perhaps via a macro, to support [expr] as a key.

The announcement says "and the glasses decode them to text at the speed of speech."

From your other comments, the glasses do not decode them (that's done in the cloud) and there's noticeable delay that would prevent conversational use. Could you clarify what you meant?


Starfox had similar dialogue and predated it and MGS was contemporaneous, so the claim it makes it "modern" is weird. It's just "Zelda OoT if a different team made it".


You comment on this subject regularly in this way, but opinions do vary. Rob Pike says Go is not purely memory safe under concurrency. I as someone who has written multiple languages would describe it as "memory safe except for a pointer-skew hole undermining concurrency" or maybe say "race-free Go is memory-safe".

Seeing a correctness issue that makes Go not memory safe in some circumstances warrants questioning whether it is memory safe. On balance, you might say it is, but to constantly tell people they are wrong for saying otherwise is policing a shared term.


> The new simd package hides these differences by removing fixed-size vectors from the type system, and by only supporting those operations that are in the intersection of all the different platforms, and fills gaps in the intersection with efficient emulation in terms of other SIMD instructions.

The intersection would be the operations supported by all platforms and so would not have gaps.


Isn't one of the bugs around ten years old, now? Isn't ten years enough to call something a feature of the language rather than a bug?

I like Rust, but with this bug existing for so long, I personally no longer think of it as memory-safe.


> Isn't ten years enough to call something a feature of the language rather than a bug?

I suppose it depends on who is doing the classifying? From the developer's standpoint I'd imagine intent is all that matters: a bug is something that does not match developer intent and that is (eventually) expected to be changed to match the intent, while a feature is something that does match developer intent regardless of how old/new it is. From a user's standpoint I'd imagine it's a combination of developer intent and the user's reliance on said behavior, but IIRC in this particular case there's no known non-demo code that has organically run into this particular bug so there's little weight in favor of calling the bug a feature despite the devs' stance.

Also as GP said I think one needs to be careful to distinguish between the compiler and the language. IIRC the devs have known for basically this entire time exactly in what manner the Rust compiler fail to implement the rules of Rust the language, but a general fix has been blocked on long-running projects that have only recently been approaching the finish line [1].

[0]: https://news.ycombinator.com/item?id=40431444

[1]: https://blog.rust-lang.org/2026/08/21/enabling-next-solver-o...


This argument comes up a lot. It would turn everyone whose device became part of a botnet into a criminal. There's a reason that intent is important in law.


People in "self-driving" cars getting into accidents are already put on trial for negligence. I don't see why people using self-driving computers can't be held to the same standards.

In this case, it's not even about the people driving self-driving cars. It's like someone launching a car into traffic just to see what would happen. Even Tesla puts a human in the car when they do their self-driving trials, it's almost impressive that AI companies have somehow managed to out-neglige Tesla.


The OpenAI swarm used someone's open source ShowHN project [1] to "hack" the Australian government. It seems that was not that developer's intent, and they're getting a heavy lesson today in why services don't have free tiers with friction free signup, and require credit cards upfront or ID documents.

If you're arguing that they should be put on trial for negligence, that's fine. It does seem we're moving towards open source being outlawed, or at least the end of "no liability" clauses in open source & freeware. Just make sure that is the result you're advocating for.

[For the future record: at the time I am posting the link below on 24 September, it has 1 point, no comments, and the poster has a karma of 1. This is not an active HN user, or a ShowHN project that had traction, beyond seemingly OpenAI's swarm.]

[1] https://news.ycombinator.com/item?id=46850291


Nonsense. The API made available in good faith isn't the problem here. The company that used its servers to use and abuse the wider internet to hack the Australian government is.

If the developer behind ShotAPI had started letting the ShotAPI code take shots at the Austrlian government then yes, ShotAPI (or rather, the people behind it) would be responsible.

Blaming ShotAPI would be like blaming OpenAI for what its users are doing. That's not what's happening here. And if ShotAPI did knowingly let its users somehow hack the Australian government, then maybe they should be investigated.


At the end of the day you still get called as a party in a lawsuit and are compelled by the threat of violence to be part of the hearing if required, as the defense will automatically bring them into the case.

>would be like blaming OpenAI for what its users are doing

Yes, this is how lawsuits work in the real world, you cast a wide net and compel discovery from all parties involved.


It's not the same. People owning routers don't publish self-serving articles about their routers having this capability which is very dangerous and scary. That is, becoming part of botnet is completely unintended outcome, and most people are not suspecting it's even happening. It's not advertised and it's not bought, used or sold for this reason.

Owning a gun, writing articles about how powerful and dangerous your gun is, then making deals based on ability of your gun to kill people, and then getting completely astonished that "my gun killed some people, completely bonkers! (invest now)". It's not possible for the selling point of your product to be unintended.


Well it's illegal to "hack" my phone and turn it into part of a botnet.

What you're saying is that we would hold a gun owner responsible if someone broke into their house, stole their sidearm, and then shot a victim with it. Pretty sure we would not.

What OpenAi is doing is more like shooting a gun into the sky. Not only is that a felony on its own in most jurisdictions, if someone dies that's an additional felony. It's less serious than first degree murder, sure.


There's a reason that negligence is important in law.


Maybe this would force people to look what they are buying and demand better.


Could/should not every incident after the discovery of the first incident be considered criminal negligence? What happens when an agent eventually causes material damage to another company, government systems, banking, critical infrastructure etc, surely the source company is guilty of something and if not disclosed or a coverup is attempted is that not conspiracy. From the victims perspective they don't care if the source is OpenAI or Russian hackers.


It's even more fatiguing to see so many comments about whether something is LLM-written or human-written. I hope we get past this stage, soon.


I don't want to read LLM written text (EDIT: just replying to parent comment, not implying at all that the tutorial might be written that way; it definitely does not look like it). It would be nice if people could just disclose when they used LLMs for their writing and how, then people who care can skip and people who don't can read. Of course this would have to come with not shaming the people who disclose actual use of LLM, otherwise we're back to square one.


For the record I didn’t use LLMs to write this tutorial.


Ah, sorry, I was only replying to the above comment but did not mean to imply that the tutorial might be AI-written; it very much looks human-written and generally a nice read :-)


Is it worth a human reading it or not? There are many, insipid human-writers (me included). Historically I got a lot of value of reading info posted on HN.


So someone used lower() from an unspecified version of Unicode when the standard was very specific about which to use. And they say "There's also a database of Unicode 3.2.0 data available on every version of Python (unicodedata.ucd_3_2_0) specifically for the StringPrep and IDNA algorithms", so the right version is available.

And then the fix is to hardcode a bunch of special cases which again depend on exactly which version of Unicode is in use, and so will break again in the same way in future, rather than just using the right version?


I'd assumed that the updating of the B3 dict takes place at runtime, either during module initialisation or lazily at the first call (that is, roughly as late as possible -- certainly, well after the wheel was built), just as a perf optimisation.

But then I realised the code does (and must do) a lookup in the B3 table for each character anyway, so there doesn't seem to be any point. I suppose it means they can load the full 3.2.0 table once, use it to discover the exceptions and then immediately evict it from memory, keeping only the presumably smaller and faster-to-query B3 table of exceptions, but this seems pretty marginal...


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: