skysight-inc/HackerNews huggingface dataset:
The primary reason Germany was so reliant on horses for logistics isn't that they weren't able to build cars, but that they didn't have enough fuel. Germany was blockaded by sea and none of the land they had captured had significant oil reserves. Romania had some, but not enough to feed their tanks and airplanes. A lot of German fuel came from coal liquefaction. About 90% of Germany's aircraft fuel and about 50% of the diesel fuel came from coal liquefaction. Contrary to what Factorio would have you believe, coal liquefaction is an expensive process- so expensive that producing enough fuel to convert your logistics supply chain from trains and horses to trucks just wasn't in the cards for Nazi Germany.

Through the lens of "Germany doesn't have enough fuel" a lot of Hitler's decision making makes a lot more sense. Lots of people talk about what would have happened if Hitler had tried to take Moscow instead of deciding to drive south towards Baku. The speculation goes that if Hitler had taken Moscow, they could have won. Well, no they couldn't: they didn't have enough oil to win the war. Baku is where all the oil is, so if Germany had been able to take Baku, it's possible that they'd be able to win. Well, they weren't able to take Baku, so they lost the war. It also explains North Africa; if the Axis were able to take Egypt, it would have been relatively easy to continue the drive on to the oil fields in the Middle East. (closing the Suez Canal would have effectively cut off the British colonies there)
> Those are normal expectation of living in society. Talking you your neighbour is not.

Errm.. yes, that's perfectly normal.
I've never heard these terms before, but I've known about this concept for a while and I've always used "implicit" and "explicit" as my descriptors for the two different approaches, which I feel have less negative connotations.
But HN still works good enough:)
You still might have to call it quits some time. Stakes just make it more difficult.
I think the point the GP is making is that with an iterator protocol, the iterator implementation itself is free to make a different choice on implementation strategies, based on the shape of the data and the hardware available, and this is transparent to client code. So for example, a container containing only primitive ints or floats on a machine with a NVidia Hopper GPU might choose to allocate arrays as a multiple of 64, and then iterate by groups of 64, taking advantage of the full warp without needing any overflow checks. Obviously a linked list or an array of strings couldn't do this, but then, they wouldn't want to, and hiding the loop behind an iterator lets the container choose the appropriate loop structure for the format and hardware.

I've heard criticisms of C and C++ that they are simultaneously too high-level and too low-level. Too high-level in that the execution model doesn't actually match the sort of massively parallel numeric computations that modern hardware gives, and too low-level that the source code input into the compiler doesn't give enough information about the real structure of the program to make decisions that really matter, like algorithm choice.

It's interesting that the most compute-intensive machine learning models are actually implemented in Python, which doesn't even pretend to be low-level. The reason is because the actual computation is done in GPU/TPU-specific assembly, so Python just holds the high-level intent of the model and the optimization occurs on the primitives that the processor actually uses.
C = Control

I think in the world of C, the compiler assumes the author knows what they're doing, and historically, you were probably supposed to use a separate tool, a linter [1] (static analysis tool), to help catch mistakes.

HN's hard disks were a recent (2022-07) victim of a firmware developer's lack of understanding of integer overflow exceptions. [2] The firmware was likely written in C, or "C++ C". A fix was released in 2020. Another reminder to update the firmware of these disks. [3]

++crash;

[1] https://en.wikipedia.org/wiki/Lint_(software)

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

[3] https://www.thestack.technology/ssd-death-bug-40000-hours-sa...
Accusation in a Mirror
"Accuse the other side of that which you are guilty" - Joseph Goebbels
It’s often two staged.

First drop hints in hopes the other party will catch on.

If that fails and you really want or still need it - you ask.
And also get rid of MVNOs.
> Because they don’t seem particularly favoured by any metric (not an advantaged majority in the space), so it's strange she would be behind this.

Ahh yes, it must be the evil white women who put the Asian woman up to this.

> Uniformity or a pattern isn’t a requirement for an argument, consistency is. And I’m consistent about the idea that people who are doing great in one area shouldn’t be pushing down other people trying to get to the same place.

I'm sure you are quite consistent in your racism.
Technical explainer by the engine sim developer:

https://youtu.be/2bJTkBsiTPc
There's only shame because there's pride. Feel ways about the world you know, it's like feeling good or bad about how the soap bubble you blow come out.
> There's always side-effect like CPU usage, temperature, mem usage, etc.

If you are writing a loop in your code with no classic side effects hoping to regulate temperature, that’s probably a bad and unreliable design to start with, whether or not the compiler optimizes it away.

If you read a temperature sensor to validate that the loop is doing the right thing and adjust frequency based on the result, its still a little crazy but its less completely insane and no longer free of classix side effects.
I don't know if you've read the book or not, or heard the arguments against it, but your response sounds exactly like the response someone would give if they only know the title of the book and that others have defended it, but is totally unfamiliar with the content.
The laws are for people, not companies... Which is why you create an LLC if you want to get away with murder
I never understood this obsession with eating eggs or milk. They seem a lot less sustainable than soy.
The issue with implementing that on traditional UNIX systems is that only root can impersonate another user. (Mechanisms such as su/sudo are achieving their goal through a setuid bit, and implement a policy using executable code in user space, which historically hasn't been without its own share of bugs.)

Next problem will be sharing data between programs that legitimately need to do so; if I had an _emacs user that owned my source code, how do I make it non-painful for the _gcc user to read the source and write the resulting executables (which would end up in a directory owned by _emacs)? What about git, various preprocessors/generators, formatters, linters?

You'd have to step out of the traditional UNIX authn/authz model to effectively implement that. It's what various security-focussed OS's have been doing for a while anyway; e.g. OpenBSD implements unveil, which "hides" entire branches of the VFS tree. For example, if git has no business reading or writing files outside of the currently operated on repository, it can restrict itself very early in the process life - before proceeding to perform any of the "tricky" operations that are the common sources of security bugs.
I see what you mean now. This has become an interesting experiment in UX. I updated the platform to leave any previous pins on the map (even if they're no longer in the top 50 results). Hopefully it works better now!
All malware infested varieties of is-true for certain!
I was looking for a python graphical interface library and came across this, I came to the conclusion that it is way too resource greedy and anything you build with it will be heavy.
People overuse and overgeneralize the term "trauma" for sure. But it might be helpful to see real actual trauma as only one item in the larger set of "stuff from your past that impacts/has influence on you today, that you mostly aren't aware of, but that if you were aware/more aware of you'd be able to handle better."

The way our primary caregivers relate and respond to us when we're a) in our most rapid periods of development and b) completely dependent on them for everything absolutely has an influence on the way we turn out. How could it not?

So there's no such thing as Neutral/No Influence, there is only identifying what effects there are and learning how to lean either into or out of those influences on a situational basis. All of this definitely applies to childhood trauma, but it doesn't HAVE to be trauma for that logic to apply. Figuring that stuff out is a helpful part of maturing, and it doesn't have to be a critical or negative thing.

In many ways I've come to appreciate and love my parents even more as I've worked through the ways they raised me the best they could, given the resources they had, but in ways that I can now see preferable alternatives to.

I think it's the biggest "I Love You" in the world to self-consciously seek to grow beyond the limitations that were passed on to me, just like I want my little girl to outgrow the ones I consciously or unconsciously hand down to her.
Right back at you? The bill in the article is a call for deregulation. Zero to do with killing competition
I'm sure we'll get there eventually. But there is a fun idea in there somewhere about a future where the only need for manned spaceflight is so we can get pinged by the computer once every few days and go and hug/wrap a tape measure around the fuel bladder
For most use cases this article is right on target.

I have been self hosting a 16K context size model and there is a lot you can do with 16K or larger context.

There are also great use cases for fine tuning. For example, if you are writing a chatbot for your company’s products, it might make sense to fine tune on product data and then RAG it with specific customer data when setting up a chat session.
https://www.wired.com/story/sim-swap-attack-defend-phone/

https://www.howtogeek.com/668922/how-to-protect-yourself-fro...
"Guests, like fish, begin to smell after 3-days"

- Ben Franklin
Those issues are because some exec in Microsoft decided that they can monetize user data and since users already don't care their data being monetized by Google, then they themselves not monetizing it as well, means leaving money on the table since users don't care anyway.

That's the logic. Using Windows web components is similar to using Google products.
How to Organize Your Qubes
>> The loophole, which a source demonstrated for The Intercept, allows genealogists working with police to manipulate search fields within a DNA comparison tool to trick the system into showing opted-out profiles. In records of communications reviewed by The Intercept, Moore and two other forensic genetic genealogists discussed the loophole and how to trigger it. In a separate communication, one of the genealogists described hiding the fact that her organization had made an identification using an opted-out profile. <<
> Facebook, Google, Amazon and GitHub have sessions that never expire. They think it’s an acceptable risk. I think they are right.

Three of these companies have a strong vested interest in keeping you logged in all the time and to minimize the friction of interacting with their services.

GitHub, if you use 2FA or corporate SSO, does expire sessions. Perhaps they make the tradeoff of risk vs convenience for username/password users, as is their right.
I will posit this proposition:

Short sessions are thinking like physical security. Someone can pick any lock, the question is will it take long enough for a human to interrupt the attack?

It doesn’t matter how long a computer has access to the key. How fast it can cause damage is limited by the speed of light, not human fingers.

If you ever leave the credentials where they are accessible, they can be used even if the session expires in three seconds. And if they’re being seen (in motion) why would the session be expiring in three seconds?

Machines hack differently than humans. Don’t think in human timeframes or orders of magnitude. That will let you make mistakes you can’t afford to make.
Uber has just posted their first profitable quarter ever. No idea if they will be able to sustain that.
Kind of the exact opposite of what I was getting at.

Anyway, automated cars are inevitable. Making them respect the law, avoid emergency vehicles, stay out of restricted areas and so on is fundamental to coexisting.

We can complain about how they can't do it right, or we can make it dead simple (and inexpensive) to get it right. Then fine them like crazy if they fail.

The idea is to make it safe for everybody. Not to assign blame.
> this article would get you thrown out of a library

I'm curious, in what country would that be the case?

Are there no books about Renaissance/Neoclassicist art in that library? Or biology for that matter?
This is what Dhall is designed to solve. If I was on a big team I’d be looking closely at it https://dhall-lang.org/
Many words have been written about this incident but it's a simple fact that they had no way of evaluating the condition of the hull. Successful dives don't mean anything because all materials degrade and they had no way of knowing how much life and margin it ever had left. The acoustic warning system was a gamble because it provided no warning of failure modes that happen quicker than the vessel could surface. The more technical arguments only serve to muddy the waters if they're not framed as addressing these more fundamental and easily understood risks.
I'd rather keep the survey data from the respected polling firm, actually. No need to assign it a weight of 100% truth, but certainly useful.
The primary "conversations" that are spawned almost entirely consist of 1. people saying no thank you and 2. people expressing concern that this will become successful.

You can stop worrying about generics causing this.

Iterators may do a bit, but I still think that based on what is currently baking that people are going to find trying to do large amounts of work through iterators is not going to scratch their itch to do everything in a foreign paradigm.

If you want to work in a certain paradigm, then for pete's sake, do it. Go do it in a language where it's the best solution. Don't find the best solution in X, then try to jam it into Y at all costs. This isn't special to X = Haskell and Y = Go, it's true for all combinations of languages.
Are we so insular as to think that lobbying for the destruction of workers rights world wide is much worse than waiting more time for a cab?
Software does degrade with age, though. Simply the fact that vulnerabilities are found over time means that our understanding of a piece of software and how it works changes. But it's not just vulnerabilities being found, it's protocols used that may be unsupported etc. That change is a kind of a rot like people call 'bit rot' but it's a specific software rot that does happen. Systems are complicated.
It’s like comparing Apache to nginx. They’re both very similar.

The biggest complaints with screen is that the source code is a disaster, and it’s slow with lots of windows, and has put mouse support.

Tmux is very configurable, I used screen from 2005 until 2017 when I went all in on Tmux. My muscle memory couldn’t adapt though. So not all my Tmux bindings match screen.
> This all seemed ridiculous to us, so instead we drove the two hours, keeping our plan secret until we pulled up into our grandma’s driveway, so that no one could resist and thwart our plan. We had a lovely visit, and my mom later thanked us for making the drive. [...] This is guess culture — and it’s a lot of saying not really what you actually want, and it’s a lot of reading between the lines to try to figure out what people want.

Guess culture here also functions as a test of love or loyalty. They are nice, so they'll say "nah, you don't have to see grandma, it's a long drive..." but in their heart they hope you will make the effort because you love your grandma. If they tell you to see your grandma, your visit in their view (and your perception too) won't have quite the same meaning. There is suspicion you saw her because you were told, not because you really wanted to.
The shorter tokes are useless by themselves; but if combined with proactive security, they can make a real difference. Some concrete examples, based on the places I worked in, which provide support for at least not having infinite expiration:

- Attacker steals Google token from regular employee.. What can they do? No, they can't "make themselves admin, or wire all your bitcoin to their account" because such things are not available for regular employees. Nor can they use email to take over account because all stuff that matters uses corporate SSO without automated password resets. So all they have access to corporate google drive, which has few terabytes of not so-valuable-stuff + important documents somewhere.

With long-living token, the attacker has plenty of time to browse around and download valuable stuff, perhaps even do it slowly so it can fly under radar. But with the shorter token, this does not work: downloading everything will take too much time / trip the alarms, and manual browsing is not fast enough. (I can imagine some sort of sophisticated AI system which auto-downloads interesting docs, but I am sure most attackers have nothing like this)

- Attacker steals AWS credentials -- again, they either have to be fast and get detected (there are alarms on unusual high download rate) or go slow and worry about token expiration. Even if they manage to steal important data, at least the expiration will force them to use faster methods more likely to trip the alarm.

Even with the full machine compromise, the short-lived tokens are useful. A npm package which steals all tokens once, at the install time, will likely go undetected. A npm package which installs a persistent backdoor will be much easier to detect.. So having a long-lived token makes attackers' lives much easier.
I'm firmly in the ask culture I guess.

Life's too short to guess. I'd rather everyone be direct, say what they want.

If it offends someone, well, sorry but too bad I guess.
I know about OVH - https://www.ovhcloud.com/en/public-cloud/databases/

Not sure about any others, personally
True but compared to eg an F150 the Hilux is 55cm shorter in length, 17cm narrower, and 10cm shorter in height. And about 900kg lighter.
> No. This is what I call the "portable assembler"-understanding of undefined behavior and it is entirely false.

"C has been characterized (both admiringly and invidiously) as a portable assembly language" - Dennis Ritchie

The idea of C as a portable assembler is not without its problems, to be sure -- it is an oxymoron at worst, and a squishy idea at best. But the tendency of compiler people to refuse to take the idea seriously, even for a second, just seems odd. The Linux kernel's memory-barriers.txt famously starts out by saying:

"Some doubts may be resolved by referring to the formal memory consistency model and related documentation at tools/memory-model/. Nevertheless, even this memory model should be viewed as the collective opinion of its maintainers rather than as an infallible oracle."

Isn't that consistent with the general idea of a portable assembler?

> I agree that undefined behavior is a silly concept but that's the fault of the standard, not of compilers.

The people that work on compilers have significant overlap with the people that work on the standard. They certainly seem to share the same culture.
I still don't understand. What was the topic of the video, and how was the image/animation involved?
The standard does make all definable UB implementation defined. The compiler writers intentionally misread the standard to allow these kinds of optimizations.

C17 Draft, § 3.4.3: "Possible undefined behavior ranges from...

. . . ignoring the situation completely with unpredictable results, to . . .

. . . behaving during translation or program execution in a documented manner characteristic of the environment (with or without the issuance of a diagnostic message) . . .

. . . to terminating a translation or execution (with the issuance of a diagnostic message)."

Compiler writers like to language-lawyer this in two ways. First, they interpret "possible" to mean that this is a non-exhaustive list, but that isn't how interpretation of such a document typically works. Expressio unius est exclusio alterius -- the express inclusion of one is the exclusion of others -- means that any list is exhaustive unless explicitly indicated otherwise. In other words, the reality is that, according to the standard, these are the only possible options.

Second, they interpret "ignoring the situation completely" to mean "actively seeking out the situation and deleting whole sections of code based on that." This is quite self-evidently a dishonest interpretation.
>"I just wish we had an IC that loved America more than its own power."

They probably think that they do love their country more than their power, while believing they need the power to protect their country. This may be a sort of 'moral corruption', though not the conventional sort. It doesn't seem 'evil' to me.
The author has co-opted the term 'Systems programmer'.

In the original Enterprise computing environment (big iron), a 'System programmer' is one that maintains the operating system, transaction processor (CICS), network stack, etc.
All I'm saying is that code doesn't have to perform stuff like prints, file write, http call in order to generate side effect

You can run heavy computation and do not do anything with the result just in order to increase CPU usage, right? (which then should result in temp increase ;))
"Performance versus correctness" is the same design tradeoff as "Worse is Better":

https://www.dreamsongs.com/RiseOfWorseIsBetter.html

However our tolerance to accept "worse" over "better" is waning since we have more capable hardware, better tools, and "worse" leads to more problems later such as security vulnerabilities.
> I agree that undefined behavior is a silly concept but that's the fault of the standard, not of compilers.

While undefined behavior is the standard's fault, its interpretation is up to the compiler.
I think it's a bit out of line to call this malice.

The C standard was written when people wanted a language that was easy to read and write, but could have similar performance to hand-written assembly. Performance, as the article title points out, was a bigger priority than correctness or eliminating foot guns.

Most of us here weren't around when many/most programs were written in assembly, and when machines were very constrained in how much memory they had and how many CPU cycles they could spare. Nowadays, performance concerns usually come behind speed and correctness of development. So it's hard to truly feel what trade offs the original designers of C (and the original C89 standards committee) had to make.

I'm not convinced implementation-defined behavior is really any better, though. Packagers and end-users should not have to ensure that the code their compiling is "compatible" with the compiler or hardware architecture they want to use. Developers shouldn't have to put a "best compiled with FooC compiler" or "only known to work on x86-64". That would not be an improvement.

I do agree that, these days, there's no excuse for writing language specifications that include undefined behavior. But C has a lot of baggage.
Why would I focus on your grandma when I can get everyone’s grandma and spread the theft out even more?

Sit in a coffee shop and steal credentials for a local bank all day.
I can honestly say I don't regret a policy of not asking people for things in general. If somebody wants me to have some of their cake, or whatever, then I'm usually happy to accept. But I can't think of a time when I am like "gee, I missed out by not asking for that thing."
Caden lands $15M to let users monetize their personal data