nextaccountic

Maybe RES (or other extension) should gain a mode where new reddit is rendered in the style of old reddit?

yishan had such plans, to distribute 10% of company shares to reddit users

https://techcrunch.com/2014/09/30/reddit-fundraising/

it was obviously abandoned though

I.. don't understand how this works at all. Why can't I ever catch it? Isn't it merely a matter of keeping the phone low?

Then, its service providers stripped the books from their bindings, cut their pages to size, and scanned the books into digital form — discarding the paper originals.

This is worse than pirating books to an absurd degree, it's almost a parody - the company that slurps all human knowledge ends up not only metaphorically, but also physically destroying those books, like an information vampire.

Authors don't even receive any financial compensation if the books were bought second hand, either. There's no benefit in doing that. (Not that making one final sale of a hardcover copy would make any difference though)

If Anthropic were at least buying ebooks, this insanity wouldn't need to happen. Unfortunately there is no bulk rates for buying millions of ebooks like you have in the used book market

I was confused on what $ORIGIN means, so, macroexpanding the article a bit

https://fzakaria.com/2026/06/21/nix-needs-relocatable-binari...

The loader in Linux however natively supports the variable $ORIGIN which translates to “the directory containing the executable.”

https://man7.org/linux/man-pages/man8/ld.so.8.html

But, if ld.so supports $ORIGIN already, why does the kernel needs to support it also? Or rather, why can't the kernel leverage ld.so and do this entirely on userspace?

I really, really wanted to make agent sandboxes work. Filed issues on the sandbox created by Anthropic and later also adopted by Copilot, and also to Codex repository. I think none of them is actually usable - they either allow too much or too little.

There is one case where VMs are not fit, and it's when you need to do GPU work. Well unless you have gpu passthrough or virtual gpus.

Elsewhere in the thread someone linked to https://pleasedonotescape.com/ which is a list of sandboxes

Maybe sandboxing isn't the job for an agent harness?

Maybe choosing a VM as your sandbox, with access only to project directory.. and then enabling YOLO mode on the agent, is the way to go.

And in any case, for an agent that can write and run code, no allowlist for which programs are allowed to run is sufficient, since the agent can just write the code the program would run anyway. And the issue isn't which software the agent runs, but whether they inherit the same ambient authority as your user - read the same files as you do, modify your config files, etc. Running in a VM stops that.

Clawk (recently submitted to HN here https://news.ycombinator.com/item?id=48892859) might be good

The network stack and virtual filesystem are implemented entirely in JavaScript

This is slightly insane

I suppose it will be slow too if the agent needs to grep over megabytes of data

Maybe https://github.com/tontinton/maki

I feel that a better title for this article would be: "Some minor annoyances that, when fixed, would improve OpenCode"

Those are labeled as "annoying things"

Read also the "alarming things"

Anthropic, OpenAI, and even Grok have "Don't train on my data" knobs.

Would you trust this?

Anthropic paid 1.5 billion for illegally training on stuff and that's even without a judge forcing them to do this. This seems to be their modus operandi

kinda wild that alibaba of all companies is making it hard to give them money tho

Okay so this is entirely off topic but, are there any options to subscribe to these companies without having a credit card? (I am Brazilian if this makes a difference)

It's kind of wild that a Chinese AI lab will require something like.. a credit card with visa or mastercard label, and very little else.

Terms of service are separate from intellectual property

I have this superstition that if I praise correct outputs, the model may use this information that previous output was correct to produce better answers in future turns

But this only makes sense in the context of a new ask, and not as a standalone message

Unfortunately, rather than exposing a common interface for many executors, the Rust async ecosystem went with a Tokio monoculture

Because of that, many libraries will depend on Tokio rather than working out of box with those different executors. Things like libraries that define protocols, etc.

This creates a strong disincentive for anyone to mess with other executors

Worse yet: with no common interface, some libraries will have feature flags to support a bunch of executors, which increases the maintenance load. Some still keep around support for dead executors like async_std while skipping support for newer executors like glommio

Anyway nowadays there are some abstraction crates in crates.io but it is too little, too late. Tokio already has an insurmountable lock in. The only thing that can start to reverse that is the stdlib itself to offer cross-executor APIs

If I gave $500 to kids cancer research every year for 5 years, and then I don't give this year, do I have blood on my hands every time a kid dies of cancer from now on? And if you didn't ever donate, you don't?

How does this work?

Okay, since the topic at hand is steelmanning, that is, replying to the strongest possible argument, let's practice that.

I invite you to watch this video, which is a short lecture that indeed exposes the strongest argument for this exact proposition.

https://www.youtube.com/watch?v=KVl5kMXz1vA (Peter Singer - ordinary people are evil)

I think the video is the best short exposition but you could try reading the paper the video is about

https://rintintin.colorado.edu/~vancecd/phil308/Singer2.pdf

Or reading about the paper

https://en.wikipedia.org/wiki/Famine,_Affluence,_and_Moralit...

the best language by a mile for dsl-as-data-structure is kdl2

it reads like code and you can easily define a schema too

well that's what i am using

https://kdl.dev/

and https://crates.io/crates/knus/ to define the schema

actually more than that. it would be awesome to have a programming language whose code is also valid as kdl 2. like lisp code being composed of s-expressions

I wonder if having springs in the bed legs would help to damp vibrations. Or.. something like that

https://engineering.stackexchange.com/questions/42284/vibrat...

https://www.bolonhome.com/news/bed-frame-vibration-control-d...

I remember a Youtube video about a story of a skyscrapper that added something to damp vibrations so that it would be more comfortable due to high winds or something like that. If it's feasible to damp vibrations on a whole building, you can do it on a smaller scale as well

Is it really more efficient? Any token becomes huge in latent space.

On another comment in this thread https://news.ycombinator.com/item?id=48902162 it is said

Toyota is still digging its heels in on gas-powered cars, even though the fact that Tesla used Japanese batteries in its early days proves Japan was once ahead of the curve.but they always seem to retreat right back into their comfort zone after a brief flash of brilliance, watching the rest of the world race ahead while they continue living in the past.

Did Japan get behind on battery tech? Couldn't them make a priority to get an edge there too?

This idea could be done with purely random frames. But they also need each frame to show a decoy to the agent (so that the agent stop looking - if they are persistent enough they could figure out the trick)

So each frame can't be 100% random and it must show some outline - but my guess is that it's the outline of the decoy, and unrelated to the outline of the actual message

And per what was reported, it's already pretty hard for the agent to figure out the decoy. After they finally crack it, they consider the problem solved

I think it's genius. The only problem is that it's trivially defeated by some tool written specifically to read it. So it defeats current-gen agents but if it becomes popular (eg. used by captcha services), future LLMs will just write a small Python script to read it

Just use https://github.com/Diolinux/Photogimp in this case

Krita is excellent for painting (specially its brush engine). The problem is Photoshop is also used for other things

Krita could refocus into a more general photo editing software, but I think they want to focus into being the best painting software instead

since getting data then doing something with it is a hidden branch if you already have the data

You mean that the naive, simpler code, despite not having an if, has a "branch" on the microarchitectural state? (which is like.. if we have this already in cache, do something. if not, do something else)

    // Find the optimal encoding for each symbol.
    // Chunk boundaries are located where encodings change.
    uint8_t encoding[n_symbols];
    uint8_t j = 0; // always start with encoding 0 for simplicity
    for (int i = 0; i < n_symbols; i++) {
        j = next_j[i][j];
        encoding[i] = j;
    }

This will also create a regulatory issue

The US government thinks they can dictate who can access "Mythos-level" (whatever that is) LLMs. But what will happen when this can be run on consumer hardware?

I guess this will be yet another vector too attack open computing and the idea that people can a) own computers, and b) choose what software they run on their own computers

The borrow checker is a good tool (and it makes Rust objectively better than Zig to me), but it unfortunately doesn't prevent writing bad code

An issue with Bun is that it interfaces with a C++ JS engine and it needs unsafe. In this case, the best practice is to write a safe binding to encapsulate this external dependency (that's why in Rust we have -sys crates with raw unsafe bindings, and other crates with a safe interface on top), and then write your business logic entirely in safe Rust

However, the Rust port of Bun didn't follow such best practices (perhaps with good SDD practices it could, not sure about that). The resulting code has literally thousands of unsafe blocks. It also contains plenty of UB. The port already costed hundreds of thousands of dollars. It's unclear if Mythos/Fable is able to refactor it further to remove unsafe usage without introducing further UB, and how much it will cost

(here It's important to note something. Rust UB is in some abstract sense harder to deal with than C or Zig UB, because it also needs to uphold the guarantees of safe Rust. If you get to write your business logic in safe Rust that's a good deal, but the price of that is that your unsafe code has extra responsibilities)

The only complaint against Haskell was about long compilation times.

There is also this

How do we make library docs full of copy-pastable, realistic examples, not just beautiful types?

Which is useful for humans as well as agents.

Haskell indeed has a very bad track record of documenting its libraries. For many people, just having the function signatures is documentation enough.

Rust is equally bad at compile times (if not worse) but its standards for documentation is at another level

The correctness function of most software is how much users want to use/pay for it, which is a pretty fuzzy problem.

This is indeed a problem, but we (well we humans, but also agents) correct this by introducing partial verifiers like tests, running lints, type checkers, etc that both verify that at least some requirements are met, and also verify that the software is internally self-consistent. And more importantly, breaking down the software into small modules that are more clearly defined

The task to get user requirements and decide the right architecture requires more creativity and is fuzzier than implementing each module. Perhaps over time there will be models specialized for each task.

And actually this approach mirrors math, if agents ever develop new math on the fly to solve a problem. Developing new math is analogous to deciding how to break up the software in modules (and also analogous to designing a language, if we subscribe to the SICP notion that libraries actually are mini-languages on their own)

That is, LLMs for math is still in the phase where they are used to prove stuff (which by Curry-Howard, is like writing code), rather than deciding what to prove (which is like deciding the signatures of each function, again by Curry-Howard)

a screenshot

The text is a video. Every frame contain random dots, so an individual frame by itself doesn't contain the intended message

This "font" exploits the fact that current-gen frontier models will process video one frame at time, but each frame is noise, so by looking at frames in isolation doesn't reveal anything

Then, they add a hidden message to each frame just so that the agent report something and stop trying (because if the agent tried to correlate between the frames, they could discover the trick)

But if you pass just a frame, there is no message. Just the noise plus the decoy

Just one thing

A model might be able to follow 200 different instructions at the same time, while another model will choke on it