skysight-inc/HackerNews huggingface dataset:
> At the same time, some state secrets are best kept secret

Yes, war crimes committed by USA and its allies are best kept secret and those committed by others are best exposed, right?

He’s not American and America are not “the good guys”. For any given secret, consider if you feel that USA should honor a request by Russia to keep it secret for the best of Russian interacts, if you don’t feel the same then its best exposed.

It’s redicules that so many Americans feel that war crimes committed by it and its allies should be kept secret because “we’re the good guys” then turn around and argue that the reason “we’re the good guys” is because we don’t commit war crimes, or when we do we at least have the decency to try to keep it secret because we know it’s bad, unlike the evil enemy who commit war crimes and try to cover it up!
To be technical Rust "creates" a lot of errors that aren't their because it doesn't, and can't, have full understanding of the control flow. Well it's less create and more complains about non issues. It why overtime code that used to be invalid Rust has become allowed as they've improved the borrow checker.
I run into the same issue with an internal company RAG, all unstructured data in PDFs but even once converted to markdown, they still need fine-tuning and a lot of manual intervention.

It feels like we are inching closer to automating this type of thing, or at the very least brute-forcing it in like the LLM race is trying to do with bigger models and larger contexts.

Will have to play with this over a weekend and see what it might help me with :)
The can of worms is not so big actually. In general, observable behavior is only I/O and volatile accesses. This is not about side effects in general (which can be optimized according to the "as if" rule). So many things can still be reordered vs potentially trapping operations. Also potentially trapping operations can be reordered. For multi-threading we have "happens before" relationship, so a natural interpretation is that everything which happens before the UB is safe.

The reordering of a volatile access after a potentially trapping operation is not conforming. I think it is an important property of volatile that it prevents this optimization, so I hope that GCC will be fixed eventually. A potentially trapping operation can also not be hoisted above a function call, and compilers that did this all got fixed in the mean time.

https://developercommunity.visualstudio.com/t/Invalid-optimi...
Some slight errors in terminology.

>> The time between two consecutive chirps is called the pulse repetition rate (PRT), and plays a key role in the accuracy of doppler velocity estimation.

This is actually known as the pulse-repetition interval (PRI), or time (PRT). A "rate" is describable by a frequency. An interval is described with a unit of time between repetitions. Radar signal characteristics are a rabbit hole of such definitions. They really do matter once one switches from theoretical discussion to actual math. Confuse a rate with a period and your math for calculating ambiguity zones will fall apart.
https://www.nytimes.com/2024/06/25/opinion/stanford-disinfor...
At least in Erlang there is a standard state machine built-in module: https://www.erlang.org/doc/system/statem.html

Most of TLS support in the built-in library is implemented using gen_statem, on top of the lower level crypto primitives provided by OpenSSL, same for SSH support.

Others have built Raft using it. It's quite nice and I appreciate that it comes as a standard module.
As someone who grew up intermittently food insecure, I am not unsympathetic to this. On the contrary, I am an aggressive supporter of broad food security policy because of this lived experience and empathy. No one should ever go hungry.

With that said, there is a discussion to be had about what effective and efficient ag policy looks like while being mindful of the above, in a world limited by physical constraints.
You don't get new theorems if you remove assumptions. Rather, you get the ability to add different assumptions.

The Banach-Tarski paradox shows that classical set theory makes the wrong assumptions to intrinsically model measure theory and probability.

There are other systems which don't suffer from this paradox and hence don't need all the machinery of sigma algebras and measurable sets.

I wish there was a good accessible book/article/blog post about this, but as is you'd have to Google point-free topology or topos of probability (there are several).
"Polyfill.io sold to a weird Chinese company and should no longer be recommended
It only works in Chrome, not Firefox or Safari. Sad.
> In a democratic society, laws should exist to protect state secrets.

Should USA really pass a law to protect Russian state secret?
No? Why should Australia or England pass laws to protect US state secrets?
Please see https://x.com/BrendanEich/status/1273250867823538176 and the quoted thread in that post.
U.S. Airports No Longer Have to Build Their Own Terrible Trains (2021)
That looks bad indeed.

I must say that contracts, while very nice for error reporting and all, also brings additional challenge related to performance (cf https://dl.acm.org/doi/10.1145/2914770.2837630). Our stance is that it's a reasonable trade off for configuration, but the cost would be unacceptable in a general purpose language.

Also, it's true that we've focused on language design and tooling before performance, and then working our way when users report unacceptable perfs on their concrete use-case.

There's been some improvement recently-ish. For example, with the latest Nickel, I get (by inlining `max` to mimic the Nix version):

$ time nix eval --expr "builtins.foldl' (l: r: if l > r then l else r) 0 (builtins.genList (x: x) 5000000)"
0,74s user 0,11s
$ time nickel eval <<<"std.array.fold_left (fun x y => if x > y then x else y) 0 (std.array.generate (fun x => x) 5000000)"
36,63s user 3,40s

Nothing to be too excited about, though. Although it doesn't make it unusable in small and medium-sized projects (we have users with 120kLoc of Nickel - with they'd definitively like to make it faster, it's still usable), I agree that performance is a big area of improvement, to say the least.
That scenario is in fact not covered by title insurance. Title insurance would be for the schmuck who bought your house.

I'm not saying that the function of title insurance companies would go away, but it would largely be obviated by an accurate single source of truth for land titling, and yes some insurance function that the government could provide for a much smaller fee.
WASM AI: run LLMs natively in the browser
Anthropic: Expanding Access to Claude for Government
huh! I tested in firefox and safari and it worked for me on both. maybe you're just running into the fact that the website is kinda dying right now?
If no Java big brother language mandate, then only nil:

https://x.com/BrendanEich/status/1672314927401549824
What is your use case, exactly? Are you trying to do some complex programmable telephony, or just make/receive calls across your personal devices?

If the latter, I think just having an iPhone and iPad or Mac will let you natively do that: https://support.apple.com/en-lamr/102405 without needing to route the call through some rando internet service.

Otherwise, there's still Google Voice, but the call quality (last I tried) was consistently mediocre to terrible.

Vonage is still around too, providing similar VOIP services to Skype: https://www.vonage.com/unified-communications/pricing/

If you want a brand-name SIP provider, Twilio offers those services: https://www.twilio.com/en-us/client/pricing

SignalWire too: https://signalwire.com/use-cases/voip

I think at the end of the day, VOIP call quality is typically too dependent on factors outside of your control (codec, bandwidth, network congestion, etc.). And there's going to be additional latency since they have to route voice calls out and through some data center and to you. If there were an easy way to up the quality consistently, probably the business providers would've done that long ago and upcharged it as "Premium Voice" or such. The cell carriers did just that with "HD Voice" and such, but that's only when they can control both ends of the conversation. That's also why purely-internet voice comms (Discord, Zoom, etc.) can sound so much better; they have end-to-end control of the traffic. Generic VOIP/SIP providers that terminate to POTS don't have that luxury.
I bike commute in SF and haven't seen any traffic enforcement at all since before COVID. I see a moving violation of some sort nearly every single day I bike (usually running red lights or right turn on red where prohibited by big glowing signs).

Apparently SF is issuing 10x fewer tickets than before COVID and 100x fewer tickets than 10 years ago:
https://web.archive.org/web/20240518142347/https://www.sfchr...
Big difference is MSFT actually makes money from dev tools. Visual studio, azure DevOps, GitHub, copilot.
AC is an axiom (something assumed without proof) and not the result that would render mathematics itself inconsistent.

Banach Tarski is not about AC, it is about existence of some pathological sets that have no measure.

Edit: AC is generally assumed to be true because rejecting it leads to even stranger paradoxes than that of Banach-Tarski.
JIT compilers can't compensate for poorly organized data. Ultimately, understanding these low-level concepts, affect high-level algorithm design and selection.

Watching the Andrew Kelly video mentioned above, really drives home the point that even if your compiler automatically optimizes structure ordering, to minimize padding and alignment issues, it can't fix other higher-level decisions. An example being, using two separate lists of structs to maintain their state data, rather than a single list with each struct having an enum to record its state.
Chemical reservoir computation in a self-organizing reaction network
What are imaginary numbers if you remove its relation to the real numbers? Do they not become regular real numbers?

How I am seeing it, real and imaginary numbers are both equivalent constructions with the same properties/construction (you can add/substract/multiply/divide them the same way), and its only in the context of using both (in the context of the complex numbers), that they can be differentiated.
In college I had the misfortune of using the CLI that Oracle provides for connecting to their database, which had the worst UX of any CLI tool I've used by far. No history, and the only way to run a previous command was with a shortcut that ran it verbatim without allowing any editing. It didn't correctly handle commands I wanted to run that I pasted in, which meant I had to type stuff out every time, and there was no ability to delete with backspace or move the cursor backwards, which meant that making a typo required clearing everything and typing it again from scratch.

On the bright side, that experience did cause me to do a little research and learn about readline, which I hadn't realized was a library I could make use of for my own stuff before then!
Evergreen https://www.arp242.net/go-easy.html
That discrepancy is not surprising, given iteration times and cost of failure. Nuclear has great potential in space exploration, but it's never going to be economical when there are other options. It's no wonder pronuclear activists clog up any discussion of renewable energy, hoping to get some of that public subsidy money for themselves - they know the reactors can't pay for themselves by selling electricity alone.
Remiss for not mentioning "rlwrap": https://github.com/hanslub42/rlwrap

...basically "readline in a can" that you can use to improve text input of other programs.

I forget if it was RMS or ESR that really wanted to hold "readline" away from corporations, so it's licensed as GPLv3 (not v2), and he explicitly wanted it to _not_ be LGPL (ie: embeddable).

My crazy readline/bash tip is `ESC, .` (or maybe `alt+.`, I'm not 100% sure, random search result here: https://gist.github.com/tuxfight3r/60051ac67c5f0445efee ). Basically it up-arrows through the last "word" of previous commands, adding it to the current command.

Example:

mkdir foo
cd `esc, .` => cd foo
vim bar.txt
cp `esc, .` baz.txt => cp bar.txt baz.txt

It's crucial in that it reduces the number of keystrokes, and avoids typing errors completely, as you're "recalling" something rather than re-typing.

I'm also in the same boat as the author in that `set -o vi` doesn't quite do it for me (although I consider myself an expert in vi). What I tend to do instead is:

C-a # <cr> => go to the beginning of the line and insert a comment char
fc => "fix command", see "help fc" (it's a built-in)

...basically it invokes: `$EDITOR "$( history | tail -1 )"` and whatever you save/quit will get executed as a command.

This lets me intentionally "damage" a command, but then get into `vim` to "fix it up" (eg: `dw, cw, df/, etc...`). Remove the comment from the beginning of the line to execute it, or keep it there to take the command back "out" of `vim` so you can keep building it up.
so you're saying we've hit that point already then?
Typical FMCW radars transmit very short ramps (microseconds) at a very long (relatively) intervals (several ten milliseconds), i.e. a duty cycle of less than 0.1%.

In order to create interference between two radars, the ramps have to overlap pretty exactly, within a few nanoseconds of each other. This is very unlikely to happen.

Modern radars employ technologies to detect and/or avoid such collisions.

Overall it is not really an issue, even with many radars in crowded spaces.
AWS AI takeover: 5 cloud-winning plays they're using to dominate the market
fascinating how Swedes are so concerned about the small number of crimes committed by the US and want the US to withdraw.

Yet they remain steadfastly silent on the crimes committed by Russia and China.

Should the US withdraw from geopolitics and allow those other two to fill the vacuum?

Like Julian Assange himself - I suspect many Russia supporters are hiding in plain sight.
Actually, in both cases, we do. Cell towers deliberately have different frequencies allocated from their neighboring towers, and Wi-Fi has multiple channels, several of which do not have any overlap.
!ɿɘƨwoɿd dɘw ɒ ni bɘnoƨiɿqmi nɘɘd ɘv'I !qlɘH
I think it’s pretty clear that the OP meant that a downside of this is that you need a GPU to run it quickly locally, not that it being local first is a bad thing.
Back in the 1980s I found a book at the public library where somebody had a BASIC program that would read a BASIC program without line numbers and with structured programming loops and rewrite it an ordinary BASIC. It was oriented towards CP/M so I typed the program in and modified it to run on my TRS-80 Coco. It was kinda like

https://en.wikipedia.org/wiki/Ratfor

Similarly I've written awk programs that write shell scripts (guilty pleasure), Python programs that write AVR-8 assembly, toolkits to write Java ASTs with static imports like

@Test
public void buildAList() {
var stream = callBuild(callAdd(callAdd(callAdd(callBuilder(), Literal.of(7)),
Literal.of(11)),Literal.of(15)));
var expr = callToList(stream);
var l = expr.evaluateRT();
assertEquals(3,l.size());
assertEquals(7, l.get(0));
assertEquals(11, l.get(1));
assertEquals(15, l.get(2));
}

and evaluate with a tree-walking interpreter or use as a code generator in maven, do transformations on the ASTs, etc.

There are many paths to metaprogramming but the Lisp family leads in putting it on your fingertips. Once you learn those methods you can apply them in the trashiest programming languages, but I think often people miss the point.
For both cases I think it's less that there isn't convenient syntax for it, and more that the generality of the syntax doesn't restrict you enough to enforce the pattern. For example, you can do a decent job approximating a monadic state machine system in C++14 with just optional and structs, so long as you follow the rule that all mutable state is kept in a state struct and all business logic must be in the form of functions with the signature optional<state>(const state&). Hell, you could even remove the optional if you don't consider there to be any "failure" cases, just cases that don't mutate the state

Then, you can use any container you like to keep track of your valid state transitions and not even have to use polymorphism. But of course C++ gives you many ways in which to trivially break this nice system of guarantees, including mutable lambdas, or even just implicit reliance on fixed memory addresses via explicit allocation and pointers in an external scope. This pattern is very general, so it's hard to capture in a guardrail
Would be interesting to see what impact some sort of llm system might be able to have on this approach. Making some changes in one area of the documentation, then having a system indicate some other likely areas of impact which you might not have considered, seems like it would be useful.
I would be very happy if you streamlined the approval process for my project.

vs.

I will donate $20k to your reelection campaign if you streamline the approval process.

Clearly the former construction could not possibly construed as an implied bribe and we shouldn't punish those who want to reward our hard working civil servants for their honorable public service. /s
Neither of those examples answers the question.

Co-channel Wifi interference is real. It really puts a damper on range and throughout compared to how it used to be. It is a largely unmitigated clusterfuck, as is the way with CSMA/CA once density increases enough.

LTE interference isn't an important thing in practice, in part because because all participating devices have very tightly-controlled timings. It isn't a clusterfuck at all because of the mitigations in place, but it does require centralized coordination to be this way.

Radars on cars don't have centralized coordination (do they?). What mechanism prevents their performance from degrading as wifi does?
Supreme Court Poised to Allow Emergency Abortions in Idaho
At the level where you're executing assembly every language is the same. Which is a way of saying that assembly is homoiconic. And even in C you're more than capable of W&Xing your binary to change behavior at runtime but you're doing it at a level below the language. It's the (not completely unrestricted) self-modifying bit that's cool
and unique. You can go into an existing function and change what it does by manipulating or outright replacing its code.

Other languages you end up having to evaluate and re-point/redefine the reference and it gets you where you need to go but not nearly as cool. For folks that liked Dijkstra's whole structured programming thing but didn't want to give up the power entirely.
> While SFPD has recently met its Vision Zero target of issuing half of the traffic citations for the top five causes of collisions, it appears that this is largely a result of fewer citations overall — not an increased commitment to Focus on the Five enforcement, Mandelman’s office said.

Ugh incentives y'all.
-120, I just want to make neat patterns :(
That’s such an uninteresting comment. Use your own money to get solar off the podium? Remember that solar received substantial subsidies to bootstrap via rooftop solar. And fission’s biggest problem isn’t necessarily funding but that there’s all sorts of regulations placed on it to stop it from being successful. So you can’t just go out and build your own nuclear plant.
Way to Measure Retention for B2C SaaS Startups
A hosted version of image generation could be useful to me because my hardware isn't very good. However, one of the main reasons to use local generation in the first place is privacy and anti-censorship. I don't see a TOS on your service. How does it handle those cases?
I was referring to the AI Act, not the GDPR.
Amazon reaches $2T market cap
As people on forums are already lamenting, the most stable API for building Linux games, is Windows.

In my mind; that is completely true and a serious indictment of the immaturity of Linux userspace.
To be very clear, I never said open-source is a problem.

In fact, Rubbrband started as an open-source project.

Each member of our team are ML researchers who have committed tens of thousands of lines to open-source.

I think you're conflating open-source with local installations. Our founding team was not fan of the interfaces that a lot of these projects have for our use cases. Not to mention, our hardware just doesn't run them.
It was completely automated. And you are right I made some assumptions.
It would be fun to attempt this with crdt's and libp2p (...or similar, I don't actually know those tools well I just like the idea of getting the server out of the loop).
tried doing:

```

$$('input[type=checkbox]').forEach(elt => elt.click());

```

and got an alert that said "CHILL LOL". fun site
Well and the realities of bad security, bad usability with touchscreen typically disabled, crappy battery life ^^'
What are some of the other verticals you're considering. What types of data sources are you using?
Kind of sick of seeing this misconception so I want to clear it up: async/await (as most commonly implemented) != pre-emptive and truly parallel multithreading.

All parallel execution is asynchronous, but not all asynchronous execution is parallel.

async/await interleaves execution in a cooperative fashion: a "fiber" runs until it yields by doing something blocking (such as blocking I/O, the most often cited use case). There are no data races and no need to use synchronization primitives since there is never a case where 2 fibers modify a piece of data at the same time: because execution is interleaved, the operations are always ordered one after the other. Whenever a fiber blocks, execution is returned to the scheduler, which resumes execution in one of the other fibers which were blocked.

fork(pthread_create)/join(pthread_join) parallelizes execution: a "thread" runs until it is done or is killed externally (the scheduler can also pause execution). A thread X can wait for another thread Y to be done by calling join(Y). There is a need to use atomics or other synchronization primitives such as channels (or mutexes, or barriers, or semaphores) when 2 threads share a variable in order to make sure only 1 at a time modifies, because although threads can be ran in an interleaving fashion (and sometimes they are interrupted (pre-empted)), they are usually ran in parallel on different CPU cores/threads (if you have a SMT CPU, which most nowadays are: n CPU cores and each CPU core has 2 "CPU threads").

P.S. A CPU thread != OS thread
Maybe, but seems more likely that our over dependence on phones and touchscreens in cars. People have more things to distract them rather than focusing on driving.
It seems though that you may be conflating wrong with hallucination. Hallucination is one class of wrong, while your example, that of reliance on an outdated training set, produces answers that are wrong but probably shouldn’t be considered a hallucination. This paper specifically addresses hallucinations.

Hallucinations are an error that occurs based on providing an answer with high uncertainty, not wrong or outdated training data.
In Italy, the most busy domestic route (Roma-Milano), was replaced by the high speed trains.
Who would take a one hour flight if you can take a 3 hour train with no security controls, more space and arrivals and departures in the city center?
Is this verified? 404 Media wrote that they got an email from the researcher impersonating Rabbit[0], but the unpaywalled part of that doesn't explicitly say that they verified the headers. I could spoof an email from president@whitehouse.gov to an email server that doesn't strictly enforce SPF etc., but that's a lot different than sending an email out via the actual whitehouse.gov mailserver.

Given the other claims, I don't doubt that researchers can do this. I just haven't yet seen a strong verification of this claim.

[0]https://www.404media.co/researchers-prove-rabbit-ai-breach-b...