skysight-inc/HackerNews huggingface dataset:
> "-w" changes visual wrapping, it doesn't save that way. No different than the behavior of "cat" in an interactive terminal really, beyond the temptation for editor religion.

What you mentioned is "soft wrapping", which is visual only but doesn't affect the saved file. But the default for nano when I first encountered it was "hard wrapping", which does affect the saved file. Some distributions later changed the default in the nano configuration file, but depending on the configuration file instead of a built-in default is risky. See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=135978 (and the five other bug reports merged into it) for an example of the problems caused by running nano in the default configuration without disabling its line wrapping.
And some people are aware that "all interpersonal conflict derives ultimately from unresolved childhood trauma" is one school of thought among many, and no more guaranteed to offer anything generally dispositive than any other.

If it worked for you, that's great! No joke, that's fantastic. But not for nothing, too, is there the old joke about the guy who just started a 12-step program and now no sooner sees someone take a drink in a bar but assumes they're an alcoholic.
Why aren't the actors blamed? I was watching 1923 and the actors Julia Schlaepfer
and Harrison Ford barely open their mouths. The actors are simply mumbling more.
Here's a simple example on accessing a PostgreSQL server from within a worker
https://workers-qb.massadas.com/databases/postgresql/
Well below the G forces experienced by smart artillery. Solid state is pretty solid.
You know the one about clearing the swamp. They spend an inordinate amount of time avoiding being bitten by crocodiles.
UX for common applications is poor. Would you want to have to enter your email password every hour or two, for instance?

I’d argue for truly critical infrastructure, short-ish session times can be useful, but for most applications they do more harm than good and better alternatives exist. For instance:

* Enforcing step-up authentication for access to sensitive application functions.

* Forcing re-auth based on behavioral analytics (for instance, if the user normally accesses an app 8 - 5 Monday - Friday from the United States, but presents a session token on Saturday afternoon from Russia, maybe force a reauth.)

* For enterprise apps, SSO where you may be forcing an authentication event every shift, but at least it is one, not one per app.

But, of course, there is no one right answer because there is no universally applicable or agreed upon threat model.
Undefined behavior is the opposite of programmer control. As the examples in the blog post show, you can write code that explicitly deferences a NULL pointer, or enters an infinite loop, and the compiler will think surely the programmer didn't mean to do that, and literally remove code that you wrote.

It's true that historically C has not done much to protect programmers from their mistakes, but historically mistakes just meant suffering the natural consequences (such as a SIGSEGV on NULL pointer dereference). But these days, when you make a mistake, C compilers will exploit your mistake to the maximum extent possible, including changing the meaning of your programs.
Gell-Mann awareness?
> will suggest aspiring fathers may want to avoid having their phones in their pockets

That's because of the heat. We know for sure that higher temperatures temporarily lower sperm production. Those "ancient patriarchal doctors with obsolete worldviews" actually know a few things.
For SpaceX in particular: if they don't do it, they're not going to Mars.

(That doesn't mean they will do it, it's just the consequence of failure).
-Wall -Werror (in cland and in think on GCC) is a good way to start.
In general, clang is great at warning at UB.
Also, address-san is a great tool
ABBA started it...
I remember watching a documentary on depression.

They did catch a jumper on camera.

They showed him pacing, hesitating, and then jumping.

Would not recommend.
That's cool and all and I'll take your statement in good faith.

However, how do I as a user report that an email that was accepted by Google's own SMTP servers was not subsequently delivered to my Gmail inbox? I can't call or email support and it is a meme at this point that Google support is only accessible via social media or contacting a Google insider.
https://brutalist.report
I think that the undefinde behaviour should be partially specified. In the case you describe, it should require that it must do one of the following:

1. Return any 32-bit answer for the right shift. (The final result will be zero due to the bitwise AND, though, regardless of the intermediate answer.) The intermediate answer must be "frozen" so that if it is assigned to a variable and then used multiple times without writing to that variable again then you will get the same answer each time.

2. Result in a run-time error when that code is reached.

3. Result in a compile-time error (only valid if the compiler can determine for sure that the program would run with a shift amount out of range, e.g. if the shift amount is a constant).

4. Have a behaviour which depends on the underlying instruction set (whatever the right shift instruction does in that instruction set when given a shift amount which is out of range), if it is defined. (A compiler switch may be provided to switch between this and other behaviours.) In this case, if optimization is enabled then there may be some strange cases with some instruction sets where the optimizer makes an assumption which is not valid, but bad assumptions such as this should be reduced if possible and reasonable to do so.

In all cases, a compiler warning may be given (if enabled and detected by the compiler), in addition to the effects above.
https://oversight.house.gov/release/comer-the-bidens-have-pu....

If Comer's claims can be substantiated there is no reasonable legal defense for these actions.

It's hard to imagine that Comer has completely fabricated all of this as well. It would have to be a lot of really huge misunderstandings.
I don't mean to burst your bubble, but... this picture of a "house of cards"-economy, with "swindles all the way down", riddled Swiss-cheese-style with corruption, while indeed a Western populist idyll visage of China these days (a sort of Western-denialists wet dream of impending Chinese doom), is inaccurate, and I think, dangerous for folks in the West to believe, if they truly hope to compete with "their biggest strategic adversary."

Surely there is corruption, failure and incompetence, but if it was on the scale that comments like this yearn for, China would look more like Cambodia, or Myanmar, or even Thailand, than China.

The simple truth is China would not have been able to achieve the scale of productivity and growth that it has (and if you doubt the scale, you must travel there in earnest, you will leave mind-expanded, if not fully blown), if it were truly like you merely wish it were. Sorry, but truth ain't always easy to hear.
This comment is astute. Homogenous vs heterogenous cultures. What flies in Los Angeles will not fly in Tokyo.
I see one name all the way down, and it's not you.
I will definitely consider adding hotels as an input option. It's definitely regional for whether I book an Airbnb versus a hotel, but most times for me it is an Airbnb based on the customer support, ratings system, and ease. However, in places like Indonesia, the hotels/resorts are a better deal than most of the Airbnbs which are not that great and have no service.
In a language without exceptions, anywhere you call something that can return an error, you have to explicitly do something with it, even if you're just returning it early (which you usually are). That's what I meant by handling. Otherwise you're using exceptions, where early-returns are implied unless you catch. In your example, probably getUser is having to handle errors too, albeit with Erlang's rather slick syntax.

I've been on both sides of this, preferring explicit handling when I was writing systems code and preferring exceptions when I was writing web backends, so I understand how to use each. Exceptions are popular in high-level languages because that's actually what people want in those use cases.

I also dislike Golang for plenty of other reasons. "Master of none" language like you implied, and late to the party with nothing special to bring other than pointless syntax differences.
Welcome to 20th century industry.
> theft is that it also immediately alerts the user

The user may or may not know of theft or leak.

And even if they are aware, they may not know remember every remote system they were logged into.

> Rotate it after 30 days if you want (or 5 days, or 1 day - just don't do it every 15 minutes).

So we've gone from arguing that short sessions doesn't work, to arguing that it works for such a large % of the cases that it could be relaxed.
That's quite interesting and reasonable
> Moderna created its vaccine in partnership with the National Institutes of Health and received $1.7 billion in federal grant money for clinical development.

Is the vaccine subject to any patents or other restrictions that would prevent a generic version? If so, why is this allowed when its development was largely paid for by the public?
A) It's a useful analogy whether or not you think it technically applies or is a perfect analogy.

B) The Windows filesystem (and to an extent the POSIX) isn't just "local", it also includes transparent and semi-transparent network file storage.

C) Windows and POSIX are both multi-user and multi-process. They operate over multiple cores and multiple I/O buses.

Even if it just one system API centralized in charge of all that, it still needs to be built on top of complex distributed dance of mutexes/locks/semaphores/other distributed control structures. Because of the nature of I/O control there are complex caches involved and transaction semantics of when data is actually pulled from/flushed to low level data stores. The transaction model in turn is reflected in what the files look like to other users or processes running at the same time.

Windows and NTFS combined have strong transaction guarantees that other users and processes must see a highly consistent view of the same files. It makes heavy uses of locks by default even for cached data. POSIX favors the "inode" approach that favors high availability and fewer locks at the cost of eventual consistency and the occasional partition (the "same" file can and will sometimes have multiple "inodes" between different processes/users, many common Linux tools rely heavily on that).

Those two different transaction models are most easily explained in analogy to CAP Theorem. They are very different transaction models with different trade-offs. Whether or not you see a single "local machine" or you see a distributed system of cores, processes, users, diverse I/O buses is partly a matter of perspective and will reflect how well you personally think CAP Theorem is a "perfect" analogy for a filesystem.
Perhaps we should do a sovereign wealth fund kind of thing where that type of funding grants the US taxpayer some common shares with no voting preference -- but if you think pure ROI -- $1.7B in investment to save millions and millions of lives worldwide isn't actually that problematic.
The One Thing I’d Change About Go
The end game for america is either a few elites living in gated communities with the rest of us living in filth, or revolution
ssss
> Machines hack differently than humans.

An awful lot of hacking is done manually, by humans. For many scenarios, considering human timeframes is completely reasonable.
It doesn't matter if triggering the exception is expensive. At that point overflow has already occured, so your program state is now nonsense, and you might as well just let it crash unhandled. Much better outcome than reading memory at some mysterious offset.

If just having the ability for an exception to occur during an instruction causes overhead, that would be a big problem though.

Edit to add: We need to do the check on every operation. Just going through one iteration of the loop might have already corrupted some arbitrary memory, for example. Manually inserted checks on some flag bits don't scale to securing real programs.
Colon cancer has been dropping since the 90s.

https://seer.cancer.gov/statfacts/html/colorect.html
It can.

.NET/C# has a `dynamic` type (aka `ExpandoObject`). That would be one way to do it (but would require casting to invoke). It's not exactly the same since you'd assign the `Func`/`Action` to a property of the `dynamic`. `dynamic` is generally avoided due to how easy it is to get into a pickle with it and also performance issues.

An alternate in this case is probably to return a tuple which I think is just as good/better.

Example:

var log = (object message) => Console.WriteLine(message);
var foo = () => log("Hello, World");
var fn1 = (foo, "This is the help text");

var commands = new[] { fn1 };
commands.ToList().ForEach(c => {
var (fn, help) = c;
log(fn.Method.Name);
log(help ?? "No help is available for this function");
});

https://dotnetfiddle.net/szxb9F

The tuple can also take named properties like this:

var log = (object message) => Console.WriteLine(message);
var foo = () => log("Hello, World");

var commands = new (Action fn, string? help)[] {
(foo, "This is the help text"),
(foo, null)
};

commands.ToList().ForEach(c => {
log(c.fn.Method.Name);
log(c.help ?? "No help is available for this function");
});

https://dotnetfiddle.net/oPK1d8

Alternatively, use anonymous types:

var log = (object message) => Console.WriteLine(message);
var foo1 = () => log("Hello, World");
var foo2 = () => log("Hello, Neighbor");

var bar = new[] {
new {
doSomething = foo1,
help = "This is foo1's help text"
},
new {
doSomething = foo2,
help = "This is foo2's help text"
},
};

bar.ToList().ForEach(b => {
var (fn, help) = (b.doSomething, b.help);
fn();
log(help);
});

https://dotnetfiddle.net/KyBtgZ

The next release of C# (12) will include named tuple types: https://learn.microsoft.com/en-us/dotnet/csharp/language-ref...

Very much looking forward to this since it gives you a lot of the same power of the JavaScript map/TS `Record`.

> ...because it's statically typed

While this is true, the `dynamic`/`ExpandoObject` is an oddity and lets you do weird things like multiple dispatch on .NET (https://charliedigital.com/2009/05/28/visitor-pattern-in-c-4...). But C# has a bunch of compiler tricks with regards to anonymous types that can mimic JS objects to some extent. The tuple type is probably a better choice in most cases, however.
As someone coming from a 'guess culture' and having a manager from an 'ask culture,' one major problem I am having is not being able to say 'no' to my manager. My manager always emphasizes the importance of asking things around rather than expecting people to just know how to help you. I know he also just asks me with the expectation that I could say no, but I always feel like letting him down if I say no. Therefore, I tend to overcommit to things and work overtime. This looks good on performance (I always got good feedback), but I'll probably burn out at some point if I cannot get this communication right.
A command line interface that converts between JSON and MessagePack
Since we're on this topic, there also seems to be enough evidence to suggest you should wear sun screen when flying.

> Pilots and cabin crew have approximately twice the incidence of melanoma compared with the general population. Further research on mechanisms and optimal occupational protection is needed.

https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4482339

As someone who enjoys looking out the window, I treat it much like going to the beach and re-apply sun screen in longer flights.
you thought that The guardian would not deliver on the promise of the click baity title ?
https://comicbook.com/thewalkingdead/news/the-walking-dead-s...
You're talking about an optimization strategy that's a few hundred thousand years old though. (And might not even be an optimization strategy at all) Its applicability to modern life seems highly dubious considering the massive cultural changes we have been going through.
I've never experienced that. When mail gets dropped, my experience is that you either receive a notice from the SMTP service or get a DMARC report that tells you about the percentage of dropped mail.
Life is already too hard, let’s not bother ourselves by being have to “guess” something.
https://twitter.com/midwestern_ope/status/122834785331730022...
People want it both ways. They want private business to use the free market to develop more efficient and better solutions than a socialized system, but also a limit to just how much that free market should compensate them.

Either you're a capitalist or you're not. If the company in question was Disney or Apple, this wouldn't be appearing on HN in any capacity.
> If your trying to fight corruption, and you have evidence this lead investigator is corrupt, couldn't you just present that evidence to get them fired?

Corrupt people (whether the corrupt official or the people corrupting them or both) often have political leverage to make that technique ineffective; that’s rather the point of political corruption.

Using aid as leverage to get other states to act in ways that local corruption would otherwise make politically unviable is neither novel nor evidence of corruption on the part of a US Administration.

In fact, its long been a foundational element of US policy in a number of areas where corruption is viewed as a wide danger.
That’s only a tiny slice of the story.

It doesn’t count the people who have opted out of the workforce.

It doesn’t count the job insecuroty of the gig economy. Or the people with terrible conditions.

It actually underscores the fact that both sexes flooded the labor pool in the last few decades, automation increased and wages got depressed due to all these factors.

USSR also had near-total employment, for men and women, way earlier than USA did. And ironically, the rent cost a ton less. But people overall couldn’t afford that much.

Your grandfather could have supported an entire family on one man’s paycheck, and paid for an entire house. Today, millennials onwards can’t afford any of that. The generation of adults with the least savings in probably a century.

But, as I said, we still have it amaing. Medical advances, technology like air conditioning, electricity and so on. The Internet spreads so much knowledge around the world. I’m just saying that the remaining problems are often rooted in economic issues, more than a rise in “systemic X ism”
JFYI: The author of the post is the CTO of Cloudflare.
Note: the title is misleading and contrary to the authors' conclusion. Where are the moderators?

"The association between cumulative dose, lagged 10 years, and solid cancer mortality was reasonably well described by a linear model (fig 1); inclusion of a parameter describing the linear association between cumulative dose and solid cancer contributed substantially to model goodness of fit (supplementary table B). The addition of a parameter for the square of cumulative dose led to only a modest improvement in model goodness of fit compared with the linear model (likelihood ratio test =2.51, df=1; P=0.11), suggesting some downward curvature (that is, a negative estimated coefficient for the quadratic term). The addition of a parameter for an exponential term in the model led to a modest improvement in model goodness of fit for a linear-exponential model compared with the linear model (likelihood ratio test =3.17, df=1; P=0.08), again suggesting some downward curvature. To assess the trend over the lower cumulative dose range, we estimated associations between cumulative dose and solid cancer mortality over restricted ranges of 0-400 mGy cumulative dose (excess relative rate 0.63 (0.34 to 0.92) per Gy), 0-200 mGy cumulative dose (0.97 (0.55 to 1.39) per Gy), 0-100 mGy cumulative dose (1.12 (0.45 to 1.80) per Gy), 0-50 mGy cumulative dose (1.38 (0.20 to 2.60) per Gy), and 0-20 mGy cumulative dose (1.30 (−1.33 to 4.06) per Gy) (supplementary table C). Over the restricted range of 0-200 mGy cumulative dose, the association between cumulative dose and solid cancer mortality was well described by a linear model, and the addition of a parameter for the square of cumulative dose led to minimal improvement in model goodness of fit compared with the linear model (likelihood ratio test=0.54, df=1; P=0.46)."

They say over and over that linear model (with relative risk = 1 at 0 dose) is a good fit! this is LNT. They say the improvements of adding the other fit are marginal. The error bounds here are large, and the deviation is small but apparently systematic or real below 200mGy. The authors, as far as I can tell, are just reporting the figures without claiming LNT is wrong.
This is a late stage capitalism phenomenon. You couldn’t say this 1000 years ago when everyone worked the land so we had enough food to survive or 200 years ago before the Industrial Revolution.

We are living in psychedelic times because the useful jobs (food, housing, consumer goods) have been industrialised to a point that a low percentage of the human population (10%?) can provide for the entirety of the other 90%.

Under normal circumstances you might say we have a distributive problem. But instead of opening that conversation we’ve maintained a now increasingly less useful economic system (it was useful for increasing the productivity of physical goods, but it’s not doing a good job with the post-materialist economy) and we say “automation does not destroy jobs” only because we’ve built fragile post industrial economies where there are lawyers and baristas (having lived in the UK this was one extreme post-industrial economy).

Effectively - we’ve automated meaningful labour so that the remaining labour is not meaningful. But because the current economic system insists you “have to have a job” then we keep making what David Graeber nicknamed bullshit jobs.

However this process does not solve climate change, poverty, crime, etc.

Instead of accepting and adopting the post-scarcity post-industrial world, we’ve molded it to our expectations of a capitalist society. Thus lies the origin of your impressions and the seeds of all our troubles.
Nowadays, in 1980's....

"Oh, it was quite a while ago. I kind of stopped when C came out. That was a big blow. We were making so much good progress on optimizations and transformations. We were getting rid of just one nice problem after another. When C came out, at one of the SIGPLAN compiler conferences, there was a debate between Steve Johnson from Bell Labs, who was supporting C, and one of our people, Bill Harrison, who was working on a project that I had at that time supporting automatic optimization...The nubbin of the debate was Steve's defense of not having to build optimizers anymore because the programmer would take care of it. That it was really a programmer's issue.... Seibel: Do you think C is a reasonable language if they had restricted its use to operating-system kernels? Allen: Oh, yeah. That would have been fine. And, in fact, you need to have something like that, something where experts can really fine-tune without big bottlenecks because those are key problems to solve. By 1960, we had a long list of amazing languages: Lisp, APL, Fortran, COBOL, Algol 60. These are higher-level than C. We have seriously regressed, since C developed. C has destroyed our ability to advance the state of the art in automatic optimization, automatic parallelization, automatic mapping of a high-level language to the machine. This is one of the reasons compilers are ... basically not taught much anymore in the colleges and universities."

-- Fran Allen interview, Excerpted from: Peter Seibel. Coders at Work: Reflections on the Craft of Programming