tlb

It's suspicious that the most important truth should contain "most important" within its statement. If you tried asking an LLM to rank the following:

1. "1+1=2" is the most important fact in mathematics.

2. "1-1=0" is the most important fact in mathematics.

3. "The most important fact in mathematics is 7" is the most important fact in mathematics.

you can see why an LLM might end up choosing #3, depending on how you ask the question.

More technically, your reasoning implicitly relies on there being a total ordering of how important various truths are. You claim (in A.2) that no truth is more important, but that would only imply that your truth is the most important truth if there's a total ordering of truths. But many truths are similarly important, so there is no total order. Even given two truths in the same domain, say 1+1=2 and 1-1=0, it's not clear that one is more important the other. You need both of those (and a few more) to construct the integers.

Tesla and Waymo must have huge data sets that could be used to correlate driver badness with the appearance of their vehicle. It's probably not in their interest to publish such data, but one can hope.

You could try adding more cowbell on a branch, test it with audiences, and revert if they don't like it.

But branches are only really useful if you can merge. If the more-cowbell branch tests well, and the faster-tempo branch also tests well, you'd like to merge them. But the file formats in music production don't generally allow such things.

Please read the Show HN guidelines at https://news.ycombinator.com/showhn.html

Unknown to the public. The NSA doesn't announce when it has pwned other countries (except sometimes much later) and China doesn't reveal intrusions the way US agencies and companies are required to.

The last desktop processor that actually promised a certain speed was probably the 68020. Everything since then has had inscrutable performance characteristics.

Google has probably sent data to almost every /24 in the last hour. Probably 99% of their egress data goes to destinations where they've sent enough data recently to make a good estimate of bottleneck link speed and queue size.

Having to pick a particular initcwnd to be used for every new TCP connection is an architectural limitation. If they could collect data about each destination and start each TCP connection with a congestion window based on the recent history of transfers from any of their servers to that destination, it could be much better.

It's not a trivial problem to collect bandwidth and buffer size estimates and provide them to every server without delaying the connection, but it would be fun to build such a system.

When and if alien life is discovered, there’s a high chance the discoverer will be someone who’s spent their career searching for it, rather than someone just stumbling across ironclad proof one fine day.

I’m inclined to let those searchers speculate in public. If society’s rule is that you can’t even speculate about X until you have proof, it will hold back science significantly. History has many such examples of forbidden speculation leading to long delays.

Is it a common use case to produce a standalone program that could be tested in isolation? Usually I'm asking for a function (or just a few lines of change) that depends on the rest of my code & environment, so it's not trivial to test.

Space is the one resource that isn't finite. And even in LEO, the amount of space is huge. It's about the same surface area of the earth, but tens of kilometers thick.

We used to have to leave a lot of space between satellites because their orbits varied unpredictably, but we've gotten better at packing them.

Someday we'll talk about the days of 5000 satellites like we talk about when computers had 4096 bytes of RAM, and it will be fine.

Please downvote or flag such comments (but only flag if you're fairly sure.)

There are lots of reasons why people don't fit at a company, and only some of them are the employee's fault. But whose fault it is doesn't really matter. If you aren't happy and aren't appreciated, you should be out interviewing for better jobs. Somewhere there's a position where you'll be both happy and appreciated.

You can just interpolate bits of Javascript inside C++ to access the DOM, like so:

  #include <emscripten.h>

  void sayHello()
  {
    EM_ASM(
      let foo = document.getElementById('foo')
      foo.innerHTML = 'hello';
    );
  }

See https://emscripten.org/docs/porting/connecting_cpp_and_javas...

I use it for a web version of some robotics simulation & visualization software I wrote in C++. It normally runs on as an app on Mac or Linux, but compiling to WASM lets me show public interactive demos.

Before WASM, the options were:

- require everyone to install an app to see visualizations

- just show canned videos of visualizations

- write and maintain a parallel Javascript version

Demo at https://throbol.com/sheet/examples/humanoid_walking.tb

The recovery process is to "only apply operations that have both intent and completion records." But then I don't see the point of logging the intent record separately. If no completion is logged, the intent is ignored. So you could log the two together.

Presumably the intent record is large (containing the key-value data) while the completion record is tiny (containing just the index of the intent record). Is the point that the completion record write is guaranteed to be atomic because it fits in a disk sector, while the intent record doesn't?

I encourage anyone who thinks these are easy high-school problems to try to solve some. They're published (including this year's) at https://www.imo-official.org/problems.aspx. They make my head spin.

There was a time when a file of source code might not fit in memory, or would take up a significant fraction of it. But it hasn't been the case on any developer machine in 20+ years. And the overhead of FILE * accessors like fgetc is substantial. Strings in memory are always going to be faster.

There are certainly things a robot can't do with rigid feet, like climbing a tree or rock face.

But anything a human can do with rigid shoes like wooden clogs should be possible. Whatever happens inside the clog stays inside.

If you're not limited to a polyhedron, a thin rod standing on end does the job.

A rod would fall over with a big clatter and bounce a few times. I wonder if there's a bistable polyhedron where the transition would be smooth enough that it wouldn't bounce. The original gomboc seemed to have its CG change smoothly enough that it wouldn't bounce under normal gravity.

It's easy to make structures that don't fail: just make them 5x stronger than anticipated max loads.

Sadly, this would make a rocket too heavy to reach orbit. So they end up being 1.1x stronger than anticipated loads. And it's hard to exactly anticipate loads. Vibration can add to a peak load, and it's notoriously hard to model how much vibration might happen. SpaceX rockets are filled with cryogenic methane at -160C, which causes everything it touches to shrink which creates forces between the parts that get cold and the parts that don't. A rocket-sized tank contracts by inches, but has to be supported by the structure around it. A single support member that doesn't move the right way can cause a fracture. So it's actually a hard problem.

The whole thing is a test. The risk of huge explosions starts when they load it with fuel, not when they fire the engines. There are risks even before that, like electrical fires or structural failures.

Yes, and (some near-future) AI is also more patient and better at multitasking than a reasonable human. It can make a change, submit for full fuzzing, and if there's a problem it can continue with the saved context it had when making the change. It can work on 100s of such changes in parallel, while a human trying to do this would mix up the reasons for the change with all the other changes they'd done by the time the fuzzing result came back.

LLMs are worse at many things than human programmers, so you have to try to compensate by leveraging the things they're better at. Don't give up with "they're bad at such and such" until you've tried using their strengths.

I don't have this problem with backtraces in Clang. The 'anonymous' lambdas have debugging symbols named after the function it lexically appears in, something like parent_function::$_0::invoke. $_0 is the first lambda in that function, then $_1, etc. So it's easy enough to look up.

It's true that you can switch very high voltages with MOSFETs in series. But the next step after switching is a transformer that needs to handle 14 MV between the primary and lower-voltage secondary winding. I don't think anyone has built something like that before. Given the dielectric strength of transformer oil, the primary windings need to be 500mm away from both the secondary windings and the core, which seems like it'd be hard to do while getting good inductive coupling.

I agree that SLS sucks because of congressional meddling to award contracts in strategic districts. But you can't have something like NASA without that. Any large government agency is doomed to have to spread work around. Only a private company run by a fearsome CEO is able to say No, we're going to go with the best solution instead of the politically favored one.

LLMs are not a linear combination of training data.

Some LLMs have interacted with the outside world, such as through reinforcement learning while trying to complete tasks in simulated physics environments.

The most general and unambiguous way to represent a diff is to just include the contents of the two files. It's more data, but that's rarely an issue these days.

So instead of `diff a b | patch c`, where the data through the pipe needs to be in some interchange format, you'd run `apply a b c` and the apply command can use whatever internal representation it likes.

Diffs also aren't great for human reading. A color-coded side-by-side view is better. For which you also want to start with the two files.

There's really no need to ever transmit a diff and deal with all the format vagaries when you can just send the two files.

Search engines were great for 10-15 years before enshittification took over. It might go somewhat faster with LLMs since the playbook is known. But that's still a long time, so why not make the most of it while it lasts? And something better may come after.

When a technology has proven business value, it's too late for seed investment. Existing companies are usually better at commercializing tech with proven business value.

The economic purpose of seed investors is to take on technology-market risk. It's a necessary part of the economy, since the only way to find out if a technology has business value is to have companies build things with it. Without investors willing to take on that risk (and lose frequently -- more than half the time) there'd be only incremental technology progress.

The original Tesla Model S went through a set of tires every 15k miles, not because of anything inherent to EVs, but because they came standard with super-soft Michelin Pilot Sport tires which give slightly higher grip than high-mileage tires. You can put harder compound tires on that last 50 or 75k miles.