knome

Quantum immortality is just an absurd quasi-religious pretense of physics that caters to those that fear death but feel embarrassed to participate in the traditional socially approved coping mechanisms.

ha. 4th grade for me, though I'm more amused than salty about the affair. who's ever heard of 'recursion'? honestly.

the first line of the article points out that python isn't run in the POSIX C handler. that just sets a flag for the interpreter to act on. the python issue is an unsafe re-entrant handling strategy in the interpreter.

>Migrant is actually the wrong word entirely, I think.

immigrant, im- (variant of in-) ; migrant into your country

emigrant, ex- ; migrant out of your country

both are still migrants. there is no specific cause for migration required to be an migrant.

you just need to move somewhere new to live.

>s/learn/be indoctrinated/

Yeah, this comment demonstrates my own perspective on it quite well, in that it's likely just another bald political attack by the current administration on education, wherein a bureaucrat will get to decide what does and does not constitute a worthwhile degree, and is allowed to become the gatekeeper of what universities may teach by selective topic by topic defunding.

Will they decide to ignore the salaries of students "not working in their field"? That could be used as an instant bludgeon against anything centered on history, philosophy, or other educational paths that do not generally have high paying careers associated with them, even if those graduating from them do generally earn more on average than those with only a high school diploma.

Twenty years ago something like half of those in tech didn't have a college degree of any kind. Plenty of businesses are run by folks that don't have college degrees. Crafting statistics through careful manipulation of who is counted for making the comparisons could be used to exclude almost any set of courses that isn't STEM, law or medicine.

For a single word response, perhaps.

But for anything else I wouldn't.

The entire chain will be affected from the different tokenization on down. Even if it lands in roughly the same semantic area, it doesn't mean it will land there with anything like the same syntactic selections. Anywhere there were multiple near-tokens could easily select a different route based on even minor fluctuations in the starting conditions. It's chaotic.

Of course they pull that kind of crap. Teens are often plenty smart, just generally naive to consequences.

They'll do this kind of stuff even if we require spybotting the entire internet. Kids already lean on sketchy older siblings or friends or stolen/fake credentials to acquire booze illegally. Getting them to sign up for and verify online accounts would be next. Or paying/doing favors for random sketchy adults. Or buying them online, as the original article mentioned.

Anything more than the equivalent of "mark this device account as being PG/PG-13/Adult" isn't buying more security for kids, just more intrusion into the lives of everyone else, while pushing access into a black market that will create new dangers for the kids entering into it.

A device flag enabling an http header indicating a device account is "PG-13" could still allow a kid to sign up to non-adult sites online, but then have appropriate restrictions on usage etc applied to the accounts. Kids can access their friends, maybe the media cuts off during school hours, but they don't feel the need to escape the system, and are more likely to stay within it.

Requiring invasive overbearing authoritarian systems be put in place with the excuse of saving the children won't accomplish the stated goal, just the unstated one.

You're a parent. Be the bad guy if you feel it's right.

Wanting the government to levy a society-wide information tracking system because you don't want your child to be upset at you is incredibly selfish.

the only difference between a thread and a process on linux is how many structures they share. the function is identical.

it's not uncommon for runtimes to use always-zero bits from aligned pointers or bits above 48 (unused in most current 64bit CPUs) to store flags today. you don't need special 'bit-addressing' to do it. byte addressing works just fine.

mandating devices provide a `NoAdult` setting, so so browsers could check it and then send something like a `x-NoAdult` header would give websites a reasonable method for distinguishing minors (or people that just don't want adult content).

it's the old 80s/90s bead curtain separating the adult movies area from the rest of the video store. it keeps kids reasonably separated, and leans on parents making their kids mind. I think that's a reasonable target.

it would work without forcing every internet user that wants to use a given service from having to submit government identification, go through interviews, or sign up to massive centralized identification systems that will inevitably track every movement people make online.

if history is any indicator, those things will lead to breaches and abuse, and people's privacy will be violated.

if there's a legally mandated way for parents to stop their kids from peeking through the internet's bead curtain, that should be sufficient for most purposes.

if the argument is that bad or foreign websites might not implement it, it's not wrong, but that same problem exists with the mass-surveillance methods as well.

if you keep going down the path of forcing everything, eventually you end up with a national firewall, vpns are illegal, anything that can provide anonymity or pseudo-anonymity online is illegal, no one has privacy, and busybodies will spend all their time hunting folks for liking things they don't want them to like when the inevitable breaches come.

to your last point, sure, a 14 year old shouldn't be able to just wonder into a liquor store, but a 40 year old should.

that's what the y-buffer is that the article mentions in the front-to-back rendering section.

it tracks how tall each columns write is so you can use it to only write the diff between it and the voxel behind it, skipping writing anything at all if the voxel behind is shorter than the current height.

So once you're done rendering front-to-back, you've got a y-buffer of highest-writes you can slap your blue sky across from highest-to-screentop on each line, avoiding the need to clear by write the sky to the full screen before starting the render.

You could avoid a full screen clear by using the y-buffer to draw in sky segments after rendering terrain.

>the algorithms love recommending AI content

wouldn't be surprised if it's because they don't have to pay out for AI music.

'berkeley packet filters', these days 'extended berkeley packet filters', are little program snippets you can inject into the linux kernel from userland programs to run logic on hooks on various events without the need to switch back to userspace.

this wouldn't catch overflow or underflow errors, nor does it allow non-base-10 numbers, nor does it handle negative numbers. and writing your own parser is a failure case by op's logic. they are complaining about the builtin parsing functions.

the author admits you can parse signed integers in their second example, but for unsigned, they don't like seem to like that unsigned parsing will accept negative numbers and then automatically wrap them to their unsigned equivalents, nor do they like that C number parsing often bails with best effort on non-numeric trailing data rather than flagging it an error, nor do they like that ULONG_MAX is used as a sentinel value by sscanf.

I'm not sure what they mean by "output raw" vs "output"

    $ cat t.c
    
    #include <stdlib.h>
    #include <math.h>
    #include <stdio.h>
    
    int main(int argc, char \* argv){
    
      char * enda = NULL;
      unsigned long long a = strtoull("-18446744073709551614", &enda, 10);
      printf("in = -18446744073709551614, out = %llu\n", a);
      
      char * endb = NULL;
      unsigned long long b = strtoull("-18446744073709551615", &endb, 10);
      printf("in = -18446744073709551615, out = %llu\n", b);
      
      return 0;
    }
    $ gcc t.c
    $ ./a.out 
    in = -18446744073709551614, out = 2
    in = -18446744073709551615, out = 1
    $

I get their "output raw" value. I don't know what their "output" value is coming from.

I don't see anywhere they describe what they are representing in the raw vs not columns.

and I might respect your opinions if they weren't couched in vapid complaints over the formatting of casual online intercourse. nobody with an argument of substance starts off with a complaint on the casing of someone's statement.

if true, your claim of the inability of the financial worker sector to absorb masses of workers dumped from a company going under due to fraud committed by the company sounds like exactly something that a social safety net would assist with, giving the workers a larger space to safely transition from one position to another.

an emotional appeal to insist on allowing a company engaged in criminal acts to persist because it might have a negative impact on those working for it isn't logical. if the company valued its employees, it shouldn't have engaged in fraud and been folded under as it deserved.

I would add another to the list, which is languages where every expression yields zero or more values, particularly `jq`. there are some antecedents in Icon and xquery, but these generally require explicitly opting into either production or consumption of value streams, where jq does this stream processing automatically from the ground up. (icon requires use of a suspend and needs an every clause to walk the generated values, xquery requires explicit 'for' statements over streams as many builtin operators fail on value streams)

in jq, the comma separates expressions, which independently yield values. a span of such expressions is called a 'filter', since they are always run by passing values from the prior filter into them (with the initial values sourcing from json objects on stdin, or an implicit null if you pass -n to the program).

    $ jq -nc ' def x: "a", "b", "c" ; def y: 1, 2, 3 ; x, y '
    "a"
    "b"
    "c"
    1
    2
    3

    $ jq -c '. + 10, . + 20' <<< '1 2 3'
    11
    21
    12
    22
    13
    23

brackets collect values yielded inside of them.

    $ jq -nc ' def x: "a", "b", "c" ; def y: 1, 2, 3 ; [x,y] '
    ["a","b","c",1,2,3]

if you have a complex object that includes multiple expressions yielding multiple values, construction will permute over them.

    $ jq -nc ' def x: "a", "b", "c" ; def y: 1, 2, 3 ; {"foo": x, "bar": y} '
    {"foo":"a","bar":1}
    {"foo":"a","bar":2}
    {"foo":"a","bar":3}
    {"foo":"b","bar":1}
    {"foo":"b","bar":2}
    {"foo":"b","bar":3}
    {"foo":"c","bar":1}
    {"foo":"c","bar":2}
    {"foo":"c","bar":3}

the pipe operator `|` runs the next filter with each value yielded by the prior, that value represented by the current value operator `.`.

    $ jq -nc ' 1,2,3 | 10 + . '
    11
    12
    13
    $ jq -nc ' 1,2,3 | (10 + .) * . '
    11
    24
    39

binding variables in the language is similarly done for each value their source yields

    $ jq -nc ' (1,2,3) as $A | $A + $A '
    2
    4
    6

functions in the language are neat because you can choose to accept arguments as either early bound values, or as thunks, with the former prefixed with a $.

for example, this runs `. + 100` parameters context, with `.` as the 10,20,30 passed to it:

    $ jq -nc ' def f($t): 1,2,3|$t ; 10,20,30|f(. + 100) '
    110
    110
    110
    120
    120
    120
    130
    130
    130

where this runs `. + 100` in the context of its use inside the function, instead receiving 1,2,3:

    $ jq -nc ' def f(t): 1,2,3|t ; 10,20,30|f(. + 100) '
    101
    102
    103
    101
    102
    103
    101
    102
    103

so you could define map taking a current-value array and applying an expression to each entry like so:

    $ jq -nc ' def m(todo): [.[]|todo] ; [1,2,3]|m(. * 10) '
    [10,20,30]

it's a fun little language for some quick data munging, but the semantics themselves are a decent reason to learn it.

the answer to that is a functional social safety net for the innocent employees to land in, not allowing companies to violate the law with impunity.

>there is no point in code-reviewing ai-generated code

the idea that you should just blindly trust code you are responsible for without bothering to review it is ludicrous.

>which buffers everything in memory

gnu sort can spill to disk. it has a --buffer-size option if you want to manually control the RAM buffer size, and a --temporary-directory option for instructing it where to spill data to disk during sort if need be.

no they don't. "department of war" is a "secondary title" of the DoD.

https://www.whitehouse.gov/presidential-actions/2025/09/rest...

only congress can change the name.

you're responsible for understanding the ramifications of things you do if a reasonable person should recognize those ramifications.

any reasonable person would have known they were interrupting emergency services. not a lawyer, but surely something akin to gross negligence would apply?

and they were doing that indiscriminate jamming as they drove around for two years.

if op is trying to cast someone making up rules in their head and going vigilante to enforce it on everyone else out of some sense of self-righteous indignation as some sort of heroic action the government is unfairly attacking, I doubt they're going to find many friendly to their perspective.

>Ironically, being anti-science is pro-science. Skepticism of institutions and consensus is the scientific method

skepticism is necessary, but not sufficient.

if they merely nay-say institutions and then go with their gut, it's certainly not.

only when someone attempts to rationally disprove a position, offering alternate testable theories and actually performing those tests is science done.

if you suspect an institution is wrong, that's fine, but it's just a hunch until someone does a test.

>How long did humanity survive without vaccines for _everything_? Oh that's right.

for most of human history, half of kids died before reaching adulthood.

Selling prisoners as underpaid slave labor means everyone else now has to compete against companies using that slave labor. It's essentially cutting us twice. We both pay to house and feed the employees/contractors of the company benefiting who then undercuts us by not bothering to pay them.

Prisons should not be allowed to be a profit center. The ramifications of doing so create gross incentives.

archeologists needing a hand from modern experts reminds me, too, of Janet Stephens.

https://classics.rutgers.edu/the-hair-archaeologist-janet-st...

I assumed they meant using the LLM to extract the citations and then use external tooling to lookup and grab the original paper, at least verifying that it exists, has relevant title, summary and that the authors are correctly cited.