MurphyA/hacker-news huggingface dataset:
by quirino | 2025-07-20 00:51:52+00:00
Not completely sure how your reply relates to my comment. I was just mentioning the competition is on Heuristics which is different from what you find on CF or most coding competitions.

About the performance of AI on competitions, I agree what's difficult for it is different from what's difficult for us.

Problems that are just applying a couple of obscure techniques may be easier for them. But some problems I've solved required a special kind of visualization/intuition which I can see being hard for AI. But I'd also say that of many Math Olympiad problems and they seem to be doing fine there.

I've almost accepted it's a matter of time before they become better than most/all of the best competitors.

For context, I'm a CF Grandmaster but haven't played much with newer models so maybe I'm underestimating their weaknesses.
by vineyardmike | 2025-07-20 00:54:05+00:00
Regulating "algorithms" doesn't mean banning. If an algorithm is used to make a decision, a human should be in the loop. There is no way these smoke detectors have any real algorithmic complexity, it's just a vague word used to hide intent and responsibility. How the EU AI agreement, focused on copyright and security, relevant to this?

I can write an "algorithm" that uses hotel data to determine if you should be charged a penalty. Now we can't question it because it was an algorithm.

> def charge_extra(data): return True
by gdbsjjdn | 2025-07-20 00:54:24+00:00
I was an early Golang dev and people were _crazy_ with channels for a couple years. I remember the most popular Golang Kafka client was absolute spaghetti of channels and routines.

It's never been "safe C" because it's garbage collected. Java is truly the comp because it's a great Grug language.

I also wrote some Erlang in the past, I really enjoy it and I was sad that Go didn't borrow more.
by hypercube33 | 2025-07-20 00:55:11+00:00
Is there anything that runs for a decent amount of time, wifi and essentially all-wireless? Blink somewhat works on its own local hub, but honestly its crap for detecting when things happen so I wont be upgrading from my used 2-pack + hub even though it does integrate well with HA.

I'd really like something that'd be apartment friendly so no drilling holes.
by Arathorn | 2025-07-20 00:55:28+00:00
sure, i just genned a new one for you: https://matrix.org/~matthew/mscs.png

The trajectory is the same, although obviously it's not ideal that the backlog grows at roughly the same rate as we merge/close them. Perhaps some day the Foundation will have enough $ to actually fund the spec core team to work on MSC review as their dayjob; meanwhile it's done in spare time or smuggled in as part of their dayjob.

Meanwhile, the fact that MSCs are being opened as fast as ever shows that folks are trying to nudge the protocol along as much as ever.
by Jedd | 2025-07-20 00:56:17+00:00
Fair that I should have spelled them out, though my point was that TFA touched on some of the considerations that are covered by those fundamental and well known concepts / terms.

Knowing the jargon for a space makes it easier to find more topical information. Searching on those abbreviations would be sufficient, anyway.

TFA talks about the right questions to consider when planning backups (but not archives) - eg 'What downtime can I tolerate in case of data loss?' (that's your RTO, effectively).

I'd argue the concepts encapsulated in those TLAs - even if they sound a bit enterprisey - are important for planning your backups, with 'self-hosted' not being an exception per se, just having different numbers.

Sure, as you say 'Do we really care about how fast we recover files?' - perhaps you don't need things back in an hour, but you do have an opinion about how long that should take, don't you?

You also ask 'should I really care about this stuff?'

I can't answer that for you, other than turn it back to 'What losses are you happy to tolerate, and what costs / effort are you willing to incur to mitigate?'. (That'll give you a rough intersection of two lines on your graph.)

This pithy aphorism exists for a good reason : )

> There are two types of people: those who have lost data, > and those who do backups.
by johnnyanmac | 2025-07-20 00:56:24+00:00
I really hope you're not a software engineer and saying this. But just as a lighting round of issues.

1. code can be correct but non-performant, be it in time or space. A lot of my domain is fixing "correct" code so it's actually of value.

2. code can be correct, but unmaintainable. If you ever need to update that code, you are adding immense tech debt with code you do not understand.

3. code can be correct, but not fit standards. Non-standard code can be anywhere from harder to read, to subtly buggy with some gnarly effects farther down the line.

4. code can be correct, but insecure. I really hope cryptographers and netsec aren't using AI for anymore than generating keys.

5. code can be correct, but not correct in the larger scheme of the legacy code.

6. code can be correct, but legally vulnerable. A rare, but expensive edge case that may come up as courts catch up to LLM's.

7. and lastly (but certainly not limited to), code can be correct. But people can be incorrect, change their whims and requirements, or otherwise add layers to navigate through making the product. This leads more back to #2, but it's important to remember that as engineers we are working with imperfect actors and non-optimal conditions. Our job isn't just to "make correct code", it's to navigate the business and keep everyone aligned on the mission from a technical perspective.
by rockskon | 2025-07-20 00:56:37+00:00
To all the people saying "fraud" is the reason - think that through.

Do you really, really think fraud and chargebacks for games covering specific fetishes on Steam have even the tiniest iota of relevance here?

Steam readily offers refunds for a multitude of scenarios!

Valve is also large enough to make itself known to payment processors to not be erroneously lumped in with seedy merchants.

From my understanding, VISA and Mastercard have relatively vague rules that payment processors must follow and payment processors must interpret that based on their own risk tolerance of adverse action being undertaken against them by VISA and/or Mastercard for not following the vague rules in the manner VISA/Mastercard interpret them as at a given point in time.

This is how you end up with situations where both payment processors and the big credit card networks point at each other when politicians ask "why are you withholding financial services from (insert company here)?" and, technically, both entities are correct at pointing the fingers at each other.

There's other factors with respect to contract law in a global economy spanning varied jurisdictions that add additional wrinkles, but I'm skeptical they're the culprit in this specific case
by metalman | 2025-07-20 00:57:01+00:00
Either you remember or you dont. My gut feeling is that careing about remebering is not good. Reading out of pure interest is good. Technical/text book's are generaly layed out in an arbitrary fashion, so I read them randomly, skimming, skimming, looking for the gems, these books are in fact poor representations of what is in the minds of the people who were "professing" there knowledge, and often there are books written outside of the curicula that are musings and collected essays, shorter books with much more in them, on the same subjects. or single subject encyclopedias that function as handy reference books, just so that you dont have to remember everything
by nothrabannosir | 2025-07-20 00:57:04+00:00
I remember very well one of the first public presentations about Go. It focused heavily on goroutines and channels and included a live demonstration of pushing an element through one million channels. It also included a demo of spinning up three racing queries to the Google search engine using the select statement, and picking whoever returned first. it was all about the new cool feature. They also had TCP-over-channels and eventually had to remove that because the model didn’t fit.

Nobody may have known they cared about Erlang, but those features sure made people pay attention.
by roxolotl | 2025-07-20 00:57:09+00:00
The challenge is that clearly stating things is and always has been the hard part. It’s awesome that we have tools which can translate clear natural language instructions into code but even if we get AGI you’ll still have to do that. Maybe you can save some time in the process by not having to fight with code as much but you’re still going to have to create really clear specs which, again, is the hard part.
by tguvot | 2025-07-20 00:57:44+00:00
this is side effect of soc2 auditor approved disaster recovery policies.

company where i worked, had something similar. i spent a couple of months going through all teams, figuring out how disaster recovery policies are implemented (all of them were approved soc auditors).

outcome of my analysis was that in case of major disasters it will be easier to shut down company and go home than trying to recover to working state within reasonable amount of time.
by crazygringo | 2025-07-20 00:58:40+00:00
> There's no type casting in Python.

If you search "type casting in Python" you will find lots of articles explaining how to use int(), str(), etc. to cast. This is a common and well-documented concept, even if it's different under the hood from e.g. C.

The idea that you'd name a function bool() and have it act differently is a deeply confusing design decision that it's understandable people would get misled by and frustrated with. This is a function named after a fundamental type. It's not a random user-defined constructor.
by birdman3131 | 2025-07-20 00:59:24+00:00
It ends up being bank dependant a bit. (USA here)

If I use either my cashapp or chime card I had better have the full $100-200 on there or it will fail the authorisation.

On the other hand my main bank is a local bank and they treat all gas station preauth's as a $1 charge. So I can have say $30 in the account and still get $25 in gas whereas many other cards/banks would just decline.
by roenxi | 2025-07-20 01:00:12+00:00
That isn't much of an argument; nothing in math is truly interesting if you take that approach. exp(i\pi)+1=0 could be said to be dis-interesting because it is just rotation on the complex plane. But it is the opposite - it is interesting because it turned out to be rotation on the complex plane but approached from summing infinite series.

Similarly you can say that solving a quadratic over complex numbers is dis-interesting, but it is actually an interesting puzzle because it is trying its best to pretend it isn't a quadratic. In many ways succeeding, it isn't a quadratic - there is no "2" in it.
by ameliaquining | 2025-07-20 01:00:58+00:00
The lamentations I usually hear about errors in Go are that you have to use a product type where a sum type would be more appropriate, and that there isn't a concise syntax analogous to Rust's ? operator for the extremely common propagate-an-error-up-a-stack-frame operation, not that you have to declare errors in your API.

Also, in my experience, the Rust maintainers generally err on the side of pragmatism rather than opinionatedness; language design decisions generally aren't driven by considerations like "this will force junior developers to adhere to the right discipline". Rust tries to be flexible, because people's requirements are flexible, especially in the domain of low-level programming. In general, they try to err on the side of letting you write your code however you want, subject to the constraints of the language's two overriding design goals (memory safety and precise programmer control over runtime behavior). The resulting language is in many ways less flexible than some more opinionated languages, but that's because meeting those design goals is inherently hard and forces compromises elsewhere (and because the language has limited development resources and a large-but-finite complexity budget), not because anyone views this as a positive in and of itself.

(The one arguable exception to this that I can think of is the lack of syntactic sugar for features like reference counting and fallible operations that are syntactically invisible in some other languages. That said, this is not just because some people are ideologically against them; they've been seriously considered and haven't been rejected outright, it's just that a new feature requires consensus in favor and dedicated resources to make it happen. "You can do the thing but it requires syntactic salt" is the default in Rust, because of its design, and in these cases the default has prevailed for now.)
by delta_p_delta_x | 2025-07-20 01:02:56+00:00
We actually tried that at first.

The technical requirement of installing WSL before installing our software was already a non-starter, since most Windows users expect one installer or zip to do-it-all. WSL2 isn't (yet) like a C/C++/DirectX redistributable which can be plugged in as a dependency to a given program. Additionally our program is expected to work natively with Windows paradigms.

More critically, we work with high-performance filesystems. The performance impact of files going a round-trip through the Linux Plan9 driver, then through a Linux kernel context switch, into the kernel, and down into Hyper-V, and then up back through the Windows Plan9 driver was completely unacceptable. It was deemed worthwhile to rewrite targeting Windows natively. And even then it was only a partial rewrite: we ended up using MinGW because we had too much of a direct dependency on the pthread API.
by ofalkaed | 2025-07-20 01:03:06+00:00
Try the wikipedia pages for Equal Temperament and Musical Temperament, they explain all of this.

Here is a 1688 Stradivari[1] guitar with fixed frets and a EDO octave, they were reasonably common by that point. Much of the information regarding this is looking at the fixed frets that many lutes and guitars had applied to their soundboard and comparing that to how composers used those fixed frets, either the tied frets adhere to the scale of the fixed frets or they are out of tune. The history of EDO/ET in fretted instruments goes back to at least Vincenzo Galilei[2] (father of Galileo) who developed the rule of 18 for fret spacing. If memory serves we have a few early steel string instrument (cittern, bandora, orpharion) from around ~1600 with equal spaced frets and this orpharion[3] looks it but it is difficult to tell from that photo. Going back earlier things get more difficult since we have so few intact and unaltered instruments but we do have a fair amount of ingravings and art plus writing on the topic such as Galilei's.

There is a paper going into great depth on all this that is just out of reach in my memory and I can't seem to trick the search engines to give it to me, I will post it if I remember/find it. No time to dig more right now.

[1]https://lsaguitarshop.substack.com/p/gear-27-the-stradivariu...

[2]https://en.wikipedia.org/wiki/Vincenzo_Galilei#Acoustics_and...

[3]https://i0.wp.com/earlymusicmuse.com/wp-content/uploads/2017...
by johnnyanmac | 2025-07-20 01:04:06+00:00
>It does not seem to matter where the code nor the legal argument came from.

You haven't read enough incoherent laws, I see.

https://www.sevenslegal.com/criminal-attorney/strange-state-...

I'm sure you can make a coherent argument for "It is illegal to cry on the witness stand", but not a reasonable one for actual humans. You're in a formal setting being asked to recall potentially traumatic incidents. No decent person is going to punish an emotional reaction to such actions. Then there are laws simply made to serve corporate interests (the "zoot suit", for instance within that article. Jaywalking is another famous one).

There's a reason an AI Judge is practically a tired trope in the cyberpunk genre. We don't want robots controlling human behavior.
by nine_k | 2025-07-20 01:04:08+00:00
Due to lack of many abstractions, and lack of exceptions, Go is a less concise Java. It's a language where the lack of expressiveness forces you to write simpler code. (Not that it helps too much.)

Go's selling points are different: it takes a weekend to learn, and a week to become productive, it has a well-stocked standard library, it compiles quickly, runs quickly enough, and produces a single self-contained executable.

I would say that Go is mostly a better Modula-2 (with bits of Oberon); it's only better from the language standpoint because now it has type parameters, but GC definitely helps make writing it simpler.
by achierius | 2025-07-20 01:04:12+00:00
> why do you believe people declaring chanting "life begins at conception" do not make preventing miscarriages into a part of their national political platform

Because it's already a national political consensus?

National health organizations go to serious lengths to make sure women are not unknowingly consuming things which would cause them to miscarry. Assaulting a woman and causing her to miscarry is penalized with charges above and beyond what would be assigned if not for the miscarriage. Societally, we try to encourage people to be gentle, careful, and accommodating towards/with pregnant women, and to encourage mothers to not drink or smoke while they're carrying.

What strawman world are you living in where this isn't the case?
by ninetyninenine | 2025-07-20 01:04:15+00:00
You just made that up. You created a connection between the Dunning-Kruger effect and positive delusion about tools. Do you have data to back that up?

I mean as much as we complain about LLMs hallucinating, here's an example of a human making shit up out of thin air. What's going on here is NOT self assessment. It's obviously assessment of an LLM.

Additionally the Dunning-Kruger effect like all of psychology stands on shaky ground.
by queenkjuul | 2025-07-20 01:04:31+00:00
Far as i can tell here, the actual advancement is in the methodology used to create a model tuned for this problem domain, and how efficient that method is. Theoretically then, making it easier to build other problem-domain-specific models.

That a highly tuned model designed to solve IMO problems can solve IMO problems is impressive, maybe, but yeah it doesn't really signal any specific utility otherwise.
by scarface_74 | 2025-07-20 01:06:18+00:00
I’m 51 now. This just came up a month ago. My response:

https://news.ycombinator.com/item?id=44377380

Get out of your bubble. The median household income is around $80K.

https://dqydj.com/household-income-percentile-calculator/

I would never want to live in the places you named. I have been to both. I live in much cheaper, warmer, state tax free Orlando. Moved from Atlanta where I spent my entire adult life until 2-3 years ago when I pivoted to a field that has historically been remote with travel.
by globalnode | 2025-07-20 01:06:39+00:00
Some ways of programming in Python require a LOT of mental effort. And some don't. For example you can do a lot in one line in Python, but I usually have to write extensive comments and references to external docs to keep track of what that one line is doing. I think sometimes it would be easier if I just had to write 3 or 4 lines of self evident code and use that as docs instead.
by duped | 2025-07-20 01:08:43+00:00
> My examples code above may not be persuasive to experienced Rustaceans. They might argue that the snippets don't show there is any real ergonomic problem, because the solutions to make the snippets compile are completely trivial. In the last example, I could just derive Clone + Copy for Id.

No, you could use destructuring. This doesn't work for all cases but it does for your examples without needing to derive copy or clone. Here's a more complex but also compelling example of the problem:

struct Graph { nodes: BTreeMap<u32, Node>, } struct Node { edges: Vec<u32>, } impl Graph { fn visit_mut(&mut self, visit: impl Fn(&mut Node, &mut Node)) { let mut visited = BTreeSet::new(); let mut stack = vec![0]; while let Some(id) = stack.pop() { if !visited.insert(id) { continue; } let curr = self.nodes.get_mut(&id); for id in source.edges.clone() { let next = self.nodes.get_mut(&id); visit(curr, next); stack.push(id); } } } }

We're doing everything in the "Rust" way here. We're using IDs instead of pointers. We're cloning a vec even if it's a bit excessive. But the bigger problem is we actually _do_ need to have multiple mutable references to two values owned by a collection that we know don't transitively reference the collection. We need to wrap these in an RefCell or UnsafeCell and unsafe { } block to actually get mutable references to the underlying data to correctly implement visit_mut().

This is a problem that shows up all the time when using collections, which Rust encourages within the ecosystem.
by scarface_74 | 2025-07-20 01:09:29+00:00
I wouldn’t go that far. I also commented about this about a month and half ago.

We should all strive to live in a position of f%%% you. (https://www.youtube.com/watch?v=XamC7-Pt8N0&pp=0gcJCfwAo7VqN...). I’m not there yet long term.
by Kranar | 2025-07-20 01:10:31+00:00
I can't substantiate your claim about Erlang or weird syntax, is that either a proper quote or some kind of paraphrasing because nothing remotely close to it comes up.

There are numerous interviews with Rob Pike about the design of Go from when Go was still being developed, and Erlang doesn't come up in anything that I can find other than this interview from 2010 where someone asks Rob Pike a question involving Erlang and Rob replies by saying he thinks the two languages have a different approach to are fairly different:

https://www.youtube.com/watch?v=3DtUzH3zoFo

It's at the 32 minute mark, but once again this is in response to someone asking a question.

Here are other interviews about Go, and once again in almost every interview I'd say Rob kind of insinuates he was motivated by a dislike of using C++ within Google to write highly parallel services, but not once is Erlang ever mentioned:

https://www.informit.com/articles/article.aspx?p=1623555

https://www.infoq.com/interviews/pike-google-go

https://go.dev/blog/waza-talk
by cyberax | 2025-07-20 01:11:30+00:00
IMO problems are not hard. They are merely tricky. They test primarily pattern recognition capabilities, requiring that flash of insight to find the hidden clue.

So it's no wonder that AI can solve them so well. Neural networks are great at pattern recognition.

A better test is to ask the AI to come up with good Olympiad problems. I went ahead and tried, and the results are average.
by pyman | 2025-07-20 01:12:40+00:00
People tend to overestimate the impact AI will have in the short term, and underestimate the impact it will have in the long term.

Do you imagine a future where journalists are AI agents, writing better than humans? Probably not, because where would they get the news from, right? But now imagine a future where AI journalists receive raw news from people all over the world. Their job is to verify, organise, and turn that information into a news article.

What about books written by AI agents, based on stories submitted by thousands of writers? Or software built by AI, based on recommendations and code examples from developers everywhere.

These agents are just machines processing the data we feed them. And that data will fuel the economy. It will create value, and the more data you produce or control, the more influence and wealth you'll have.

Those who can't contribute data may end up living on a universal basic income.