* EDIT * What's with the downvoting? That's a correct description of what happened. You can't ask an LLM why it did something and expect a coherent response, because there's no thinking chain, and no stored thinking state... At best, you can get a reconstruction of how the context relates to the output (basically a summarization of the context).

It's hard to tell you, because it's subjective, I don't swap back and forth between an SSD and the optane drives. I have my old system, which has a 2TB Samsung 980 Pro NVME drive (PCIE 4.0 x4, or 8GB/s max) as root, and a Sabrent rocket 4 plus 4TB drive secondary (also PCIE 4.0), so I ran sysbench on both systems, so I could share the differences. (Old system 5950X, new system 9950X3D).

It feels snappier, especially when doing compilations...

Sequential reads: I started with a 150GB fileset, but it was being served by the kernel cache on my newer system (256GB RAM vs 128GB on the old), so I switched to use 300GB of data, and the optanes gave me 5000 MiB/s for sequential read as opposed to 2800 MiB/s for the 980 Pro, and 4340 MiB/s for the Rocket 4 Plus.

Random writes alone (no read workload) The optane system gets 2184 MiB/s, the 980 Pro gets 32 MiB/s, and the Rocket 4 Plus gets 53 MiB/s.

Mixed workload (random read/write) The optanes get 725/483 as opposed to 9/6 for the 980 Pro, and 42/28 for the Rocket 4 Plus.

2x1.5TB Optane Raid0: Prep time: `sysbench fileio --file-total-size=150G prepare` 161061273600 bytes written in 50.41 seconds (3047.27 MiB/sec).

    Benchmark:
    `sysbench fileio --file-total-size=150G --file-test-mode=rndrw --max-time=60 --max-requests=0 run`
    WARNING: --max-time is deprecated, use --time instead
    sysbench 1.0.20 (using system LuaJIT 2.1.1741730670)

    Running the test with following options:
    Number of threads: 1
    Initializing random number generator from current time

    Extra file open flags: (none)
    128 files, 1.1719GiB each
    150GiB total file size
    Block size 16KiB
    Number of IO requests: 0
    Read/Write ratio for combined random IO test: 1.50
    Periodic FSYNC enabled, calling fsync() each 100 requests.
    Calling fsync() at the end of test, Enabled.
    Using synchronous I/O mode
    Doing random r/w test
    Initializing worker threads...

    Threads started!

    File operations:
        reads/s:                      46421.95
        writes/s:                     30947.96
        fsyncs/s:                     99034.84

    Throughput:
        read, MiB/s:                  725.34
        written, MiB/s:               483.56

    General statistics:
        total time:                          60.0005s
        total number of events:              10584397

    Latency (ms):
             min:                                    0.00
             avg:                                    0.01
             max:                                    1.32
             95th percentile:                        0.03
             sum:                                58687.09

    Threads fairness:
        events (avg/stddev):           10584397.0000/0.00
        execution time (avg/stddev):   58.6871/0.00

    Benchmark:
    `sysbench fileio --file-total-size=150G --file-test-mode=rndrw --max-time=60 --max-requests=0 run`
    WARNING: --max-time is deprecated, use --time instead
    sysbench 1.0.20 (using system LuaJIT 2.1.1741730670)

    Running the test with following options:
    Number of threads: 1
    Initializing random number generator from current time

    Extra file open flags: (none)
    128 files, 1.1719GiB each
    150GiB total file size
    Block size 16KiB
    Number of IO requests: 0
    Read/Write ratio for combined random IO test: 1.50
    Periodic FSYNC enabled, calling fsync() each 100 requests.
    Calling fsync() at the end of test, Enabled.
    Using synchronous I/O mode
    Doing random r/w test
    Initializing worker threads...

    Threads started!

    File operations:
        reads/s:                      594.34
        writes/s:                     396.23
        fsyncs/s:                     1268.87

    Throughput:
        read, MiB/s:                  9.29
        written, MiB/s:               6.19

    General statistics:
        total time:                          60.0662s
        total number of events:              135589

    Latency (ms):
             min:                                    0.00
             avg:                                    0.44
             max:                                   15.35
             95th percentile:                        1.73
             sum:                                59972.76

    Threads fairness:
        events (avg/stddev):           135589.0000/0.00
        execution time (avg/stddev):   59.9728/0.00

    Benchmark:
    `sysbench fileio --file-total-size=300G --file-test-mode=rndrw --max-time=60 --max-requests=0 run`
    WARNING: --max-time is deprecated, use --time instead
    sysbench 1.0.20 (using system LuaJIT 2.1.1741730670)

    Running the test with following options:
    Number of threads: 1
    Initializing random number generator from current time

    Extra file open flags: (none)
    128 files, 2.3438GiB each
    300GiB total file size
    Block size 16KiB
    Number of IO requests: 0
    Read/Write ratio for combined random IO test: 1.50
    Periodic FSYNC enabled, calling fsync() each 100 requests.
    Calling fsync() at the end of test, Enabled.
    Using synchronous I/O mode
    Doing random r/w test
    Initializing worker threads...

    Threads started!

    File operations:
        reads/s:                      2690.28
        writes/s:                     1793.52
        fsyncs/s:                     5740.92

    Throughput:
        read, MiB/s:                  42.04
        written, MiB/s:               28.02

    General statistics:
        total time:                          60.0155s
        total number of events:              613520

    Latency (ms):
             min:                                    0.00
             avg:                                    0.10
             max:                                    8.22
             95th percentile:                        0.32
             sum:                                59887.69

    Threads fairness:
        events (avg/stddev):           613520.0000/0.00
        execution time (avg/stddev):   59.8877/0.00

This is something I have been thinking about and researching for awhile, because there is so very much confusing language out there.

Your quote says over the last century, so I'm going to use roughly 1920 as the baseline. It also refers to a per capita increase of meat consumption by 100 pounds, or about 45.4 kilograms (to make the math easier). This is roughly an increase of 124g of meat per person per day (or about 3oz if that makes more sense to you).

This equates to a daily increase in per-capita protein intake by 25-30g (depending on which meat and how lean it is).

In 1920, the average American adult male was about 140 pounds, and ate about 100g of protein per day, which works out to roughly 0.71 grams per pound of body weight (or about 1.6 grams per kilogram).

In 2025, one century later, the average American adult male is 200 pounds, and if he eats the same ratio of weight to protein, you would expect that he would eat around 140g of protein per day, which is slightly higher than the increase in per-capita meat consumption over the same time.

However, if you look at actual statistics of what people are eating in protein, you'll see that the average American adult male is actually eating about 97g of protein per day, or about 0.49 grams per pound (1.1 grams per kg), which is much less than we ate a century ago, which means that that the increase in meat consumption doesn't match change in protein, so is offset by either less non-meat protein, meat with lower protein content (e.g. more fat), or both.

There was some discussion lower in the thread about bodybuilders vs normal people, and about basing your calculations on lean body weight vs full bodyweight. Lean body weight calculations are often used for bodybuilders, but those numbers are elevated (typically 1 gram of protein per pound of lean body weight). For someone who is sedentary to lightly active (e.g. daily walks), the calculation is based on full body weight, not lean body weight, and is about 0.7 gram per pound (or 1.5 grams per kilogram), which matches this recommendation exactly.

Hitting these targets has been shown to greatly increase satiation, reduce appetite, but it does not make you lose weight, and it is not permanent (reducing your protein intake removes the effect, which makes sense). However, long term studies show that people who increase their protein intake to these levels and lose weight (through calorie reduction or fasting) keep that weight off.

Finally, from what I've been able to cobble together, high protein intakes combined with high fat and high sugar intakes does not have the same effect as a diet that matches the recommendations here (ie. it's not just about higher protein intake, it's about percentage of calories from protein, which should be around 20-25%... 200 pound sedentary to lightly active adult male, 140g of protein, or 560 calories, in a total diet of 2250-2800 calories, depending on activity level)

Since then, I've made sure every single TV I own has this turned off (I go through the menu extensively to disable, and search on Google and reddit if it's not obvious how to disable like the case with Samsung).

I have an LG Smart TV, and just a week or two ago I was going through the settings and found Live Plus enabled, which means either they renamed the setting (and defaulted this to on), or the overrode my original setting.

Either way, I'm super annoyed. I want to switch to firewalling the TV and preventing any updates, but I need a replacement streaming device to connect to it.

Does anyone have recommendations for a streaming device to use (presumably one with HDMI CEC, that supports 4k and HDR)? I use the major streaming services (Netflix, Prime, Hulu, Apple TV) and Jellyfin.

We did extensive experimentation, and later user studies to find out that there are roughly three classes of people:

1) Those that use interface items with text 2) Those that use interface items with icons 3) Those that use interface items with both text and icons.

I forget details on the user research, but the mental model I walked away with this that these items increase "legibility" for people, and by leaving either off, you make that element harder to use.

If you want an interface that is truly usable, you should strive to use both wherever possible, and ideally when not, try to save in ways that reduce the mental load less (e.g. grouping interface by theme, and cutting elements from only some of the elements in that theme, to so that some of the extra "legibility" carries over from other elements in the group)

When you have accurate matchmaking, you will be playing against other players of a similar skill level. If you we're playing in single-player mode, it wouldn't bother you that some of the players were better than others.

Whether the person you're playing against is as good as you because they have aim assist, while you have a 17g mouse and twitch reflexes shouldn't matter. You're both playing at equivalent skill levels.

The only reason it matters to anyone is that they want their skills to be recognized as better than someone else's. Take down the leaderboards, and bring back the fun.

I say, let the people cheat.

I wish the 55" 8k TVs still existed (or that the announced 55" 8k monitors were ever shipped). I make do with 65", but it's just a tad too large. I would never switch back to 4k, however.

I run a ttyd server to get terminal over https, and I have used carbonyl over that to get work done. That's limited to a web browser (to get access to resources not exposed via the public internet), so having full GUI support is very useful

I looked it up, and it turns out you're right. Both the iPhone 17 and the iPhone Air use USB2.

USB3 was introduced in 2008 (!!!). That is 17 years ago.

I already wasn't interested in this tech, to be fair, but I've had to support family phones synchronizing/backing up over the cable, and even at full theoretical speed for the transfer, we're talking over an hour vs just under 7 minutes. Which, considering the flash most likely suppports the read in under a minute, is crazy.

"and the 2x telephoto has an updated photonic engine, which now uses machine learning to capture the lifelike details of her hair and the vibrant color of her jacket"

"like the 2x telephoto, the 8x also utilizes the updated photonic engine, which integrates machine learning into even more parts of the image pipeline. we apply deep learning models for demosaicing"

We had caffe2 running a small model on the phone to try and select and propose photos for the user to share.

We were trying to offer an alternative sharing model that both made sharing easier, while offering the user the controls that made them feel comfortable with photo suggestions. (for those who never noticed, we launched Moments, which was an app that allowed automatic private sharing of your camera roll with a close selection of friends and family, but the experience wasn't great because it was centered around group events and sharing photos with the people who were there, not connecting with the ones who weren't)

Ultimately, it was scrapped, because we were paranoid that we hadn't come up with a user experience that made it clear that this was happening only on the phone (I think we even tried a notification model), or that we'd accidentally surface someone's boudoir photos, and we were too worried about the kind of knee-jerk reactions that you're seeing in this thread.

I'm guessing that someone at Meta either had a more successful go at the UX, or they feel that the opinions about AI have shifted enough that there will be less fear.

Upon reading the article, it looks like there are two options, one which is local-only, and similar to what we built, and a second one which tries to make better suggestions using online, and that is only enabled after asking the user.

I would suspect that the cloud processing version also runs a local model to attempt to filter out racy photos before sending them to the cloud, but I don't know for sure.

I think the article is a bit disingenuous in it's presentation, but it's possible that I'm biased because I know how a similar thing was built, but it definitely sounds like fear-mongering.

This was suggested to me six months ago by someone who was extreme right wing, (going as far as to say that the FAA only hired non-white employees) and I found the claims bizarre enough to research on my own. They claimed that this was a known fact, whether you read left or right news sources, but when I did my research (not on bias, but on actual hiring results), it said that historically, the FAA has been about 90% white, and currently is about 70% white (IIRC), which is a far cry from suggesting that the FAA has race and gender quotas.

Again, here, the article makes the same claim, but this time with a citation (!), so I wondered if there was some truth to it, that I missed, earlier, but again, the truth does not pan out. It seems that a few members of the NBCFAE (National Black Coalition of Federal Aviation Employees) stepped over the line in their attempts to to change hiring practices that were preventing black candidates from being considered (going from increasing the diversity of the candidate pool, which is laudable, to discriminating in order to change up the racial mix, which is illegal).

However, in all of this, it's not the FAA acting, just a few powerful individuals from the NBCFAE. That doesn't change the fact that something bad happened, just the characterization of it ends up being completely misleading.

https://ai.google.dev/gemma/docs/core/huggingface_text_full_...

It's a command line web-browser that uses a headless GUI browser (in this case chromium) in order to surf the web and render it to the terminal. brow.sh preceded it (powered by Firefox), but in my testing, carbonyl has much better web support.

In any case, here's a very brief demo: https://asciinema.org/a/HLHWeKE2s5bdyhUGQPBum49kx

It's so short because the bandwidth is high to use it, and asciinema.org rejects casts that are greater than 10MB

Alice has $100 in burrito debt at 0%, but misses one payment, which automatically reverts to a 30% interest rate, back-tracked to the start of the "loan".

She also receives a $7 late payment fee, which is equivalent to about 90% interest for the time covered.

Her bank will often re-order operations on a given day in order to maximize the fees charge (yes, this happens, yes, this is legal), so even if she had her paycheck arriving on the same, the operations will often be sequenced with largest debits first, followed by credits, so that the overdraft hits as early as possible, and the most possible number of failed payment fees can be extracted, followed by the credit, which is now greatly reduced

(I actually had this happen to me as a student once, five late payment fees because of re-ordering, which caused me to both never let this happen again, and change banks immediately for one which wasn't as predatory).

Burrito loans are like payday loans, but even more predatory... They are neither ethical, nor moral (usury is even covered in the old testament, for christian folk).

What would you call Americans? United Statesians?

There are two countries called the United States in North America, there's the United States of Mexico, and the United States of America. People from the United States of Mexico are called Mexicans, and people from the United States of America are called Americans.

And what about people from the continent of North America? There's called North Americans, just like people from South America are called South Americans.

I'll take a short cut and imagine that you have an 8x8 square with no margins (68% of a borderless 8.5x11), then you have a grid of 600x600 bitmaps, which is 3.6e5. if each pixel is only black or white, than you have 1.8e19 possible bitmaps (64-bit), divide the two and you have 5e13, or about 50 trillion pages. Fix the equation, and you get a grid of 5.2e5, for 30 trillion pages instead of 50.

However, bring that up to 24-bit color or more (even 8-level greyscale is e154), and the exponentiality of the problem goes back to as described by the OP