MurphyA/hacker-news huggingface dataset:
by zahlman | 2025-12-13 20:35:02+00:00
> the glaring shortcoming which is that, since dictionary keys are required to be hashable, Python has the bizarre situation where dicts cannot be dict keys

There is nothing at all bizarre or unexpected about this. Mutable objects should not be expected to be valid keys for a hash-based mapping — because the entire point of that data structure is to look things up by a hash value that doesn't change, but mutating an object in general changes what its hash should be.

Besides which, looking things up in such a dictionary is awkward.

> More generally, sometimes you have an array, and for whatever reason, it is convenient to use its members as keys.

We call them lists, unless you're talking about e.g. Numpy arrays with a `dtype` of `object` or something. I can't think of ever being in the situation you describe, but if the point is that your keys are drawn from the list contents, you could just use the list index as a key. Or just store key-value tuples. It would help if you could point at an actual project where you encountered the problem.
by jack_tripper | 2025-12-13 20:35:23+00:00
>> “I was wrong,” the former German finance minister, Wolfgang Schäuble, says, simply. “We were all wrong.”

So when are they retroactively giving back their salaries and pensions for having fucked up the livelihoods of their taxpayers?

Politicians have no incentive to ever make good decisions for the future of their country without any skin in the game from which their personal riches are derived.

>We win or we learn.

Jensen Huang said that failure is learning but sometimes failure is just failure and you should know when to cut your losses before the failure goes from learning to bankruptcy. And Germany did far more failure than actually learning.
by Enginerrrd | 2025-12-13 20:35:24+00:00
I’m a little out of my depth, but I’d guess a lot of them would probably fall into one of two categories: Something we believe should go on forever (and not halt) if the math problem is resolved the way we expect, but theoretically could suddenly halt after some absurdly long number of steps. Or something where it halts for a given input after some number of steps unless something some counter example exists where it goes on forever.

In the first, you can’t really do anything but just keep watching it not halt but it isn’t telling you anything about the infinity to go. (Say a program that spits out twin primes, we expect an infinite number but we don’t really know)

And in the second case we’d just have to keep trying larger and larger inputs making this just an extension of the first category if we wrote a program to do that for us. And if we did find an example where it goes on forever without repeating states, how would you even know? It’d be like the first situation again.
by dotancohen | 2025-12-13 20:35:35+00:00
I drove for six hours with my son last night to watch the Geminids. We watch the Persids every year, but this time was the first to watch the Geminids. They are a very different shower, we could immediately see the difference.

My advice: use online dark sky maps to find the darkest places. It makes a huge difference. And for this winter meteor shower, look at the current satellite imagery for your area to find a place with little cloud cover.

Do not use your phone while out there! Live without it for a few hours. The phone, and flashlights, vastly affects how well your eyes will see the meteors. Remember, you are literally looking at objects the size of a grain of sand, 100 to 200 kilometres away.

Bring hot chocolate in a large thermos. And warm hats. And somebody you love.
by luqtas | 2025-12-13 20:37:10+00:00
i recommend you starting with something easy to digest like this: https://www.amazon.com/Energy-Society-David-Pimentel-Ph-D/dp...

then you can move on and judge what't the panorama of closed/paywalled science found out there (Nature) that evaluates impacts of solar panel not even considering numbers of last batches of thrash from ~ 2010 (which still have 10-15 years till they start filling the world with chemicals like lead)... then may dive into electricity security and distribution and recycling technology to bring up a single ignorant phrase comment downsizing nuclear generation, despite it being safer and ecological on the long-term compared to photovoltaics in LOTS of places, for example
by rdrd | 2025-12-13 20:37:30+00:00
Yes I too have found newer models (mostly Opus) to be much better at iterative development. With that being said if I have very strong architectural/developmental steer on what I believe the output should be [mostly for production code where I thoroughly review absolute everything] it’s better to have a documented spec with everything covered rather than trying to clean up via an agent conversation. In the team I’m in we keep all plan.mds for a feature, previously before AI tooling we created/revised these plans in Confluence, so to some degree reworking the plan is more an artefact of the previous process and not necessarily a best practice I don’t think.
by dragonwriter | 2025-12-13 20:37:51+00:00
> So forums and blogs can still exist but if you do any sort of not strictly legally required moderation you have legal liability for all content without 230.

Which means the consequence for any mistake on sticking exactly to the bounds of legally mandatory moderation is enormous liability (either massive civil liability if you go slightly beyond the bounds of the minimum, or given the source of most minimums catastrophic criminal liability if you fall below it); the only realistic approach at non-trivial scale is just not to allow UGC except at the level you are willing to edit as if it were first party content you were going to be fully responsible for.
by seanhunter | 2025-12-13 20:38:36+00:00
I’m not disagreeing. I’m pointing out that in TFA it sounds as associativity is a property of abelian groups specifically whereas it as a property of all groups in general. In that sense it’s not wrong, just the emphasis is a bit misleading.

If you look in an abstract algebra textbook they all basically say the same definition for abelian groups (eg in Hien)

> “A group G is called abelian if its operation is commutative ie for all g, h in G, we have gh = hg”.
by pletsch | 2025-12-13 20:39:01+00:00
I think a lot of it boils down to your goals with it, I'm personally very engaged with my user base and take pride in my communication and you may not value that over less work/more dev time. This is also for an internal tool but the audience is diverse (500+ devs, cybersecurity engineers, leadership, writers, etc), I stick with one set of release notes for a few reasons:

- One location, people who may fall into multiple categories (or none) don't need to check multiple places, users also know that all my communication will be via that page/they don't have to wonder if they're missing something

- As much as some detail doesn't matter to certain audiences, I find being able to give all the detail you want a user to know while maintaining readability to less technical audiences is a skill worth developing because the result is regardless of where your notes end up, the person will understand what's changed and why it matters

- Maintaining multiple versions leads to mistakes, at some point you'll leave out a detail to one audience that matters so letting the user mentally filter what they don't care about takes the onus to get it right 100% of the time off of you. I'll often categorize my changes by the section that had the change to help users with this.

- This is a personal preference and you touched on this one but it's just far less work, I've found it common in tech that people don't want to do things more than once or they'll automate it/look for shortcuts and this is no different. This isn't always a bad thing but getting release notes right means your users stay informed/use new features which is why we build them so I think it's worth putting my energy into doing it properly every time
by culi | 2025-12-13 20:39:28+00:00
https://iselmdead.info/

I can't believe this is still up tbh. And I can't believe there's still people defending Elm's lack of development

> It’s true that there hasn’t been a new release of the Elm compiler for some time. That’s on purpose: it’s essentially feature-complete.

Last talk I saw by Evan Czaplicki (from the 2025 Scala Days conf) he seemed to be working on some sort of database language https://www.youtube.com/watch?v=9OtN4iiFBsQ
by Fogest | 2025-12-13 20:39:32+00:00
Yeah that pretty much describes every big companies release notes. I used to have manual updates in the Google Play store as I enjoyed seeing what was changing. But over time so many companies just started saying things like "Security fixes" and it became a waste of time even bothering to look at them.

And sometimes they do actually add a feature... but they'll mention it within the app itself despite the app updates not mentioning it. Or even more funny is how often I'll see a news article talking about the new feature, but then it never even gets mentioned in the release notes anywhere.
by zozzle | 2025-12-13 20:39:35+00:00
> the BBC gave JK Rowling a Russel Prize for her anti-trans manifesto

It wasn't an "anti-trans manifesto", but a thoughtful explanation of her reasons for speaking out on the sex and gender issue, where she discusses her concerns for women's rights and safety, the well-being of vulnerable children, and how important it is to be allowed to speak freely on this topic. Plenty of people on the left (and centre-left) agree with her too.

As with all her work, it was very well written, which the article you linked rightly acknowledges.
by RadiozRadioz | 2025-12-13 20:39:39+00:00
While more automation certainly is useful, I find that auto-generating changelogs in this manner has a number of problems:

Auto-genertaed changelogs lack business-aware context about what is important. You get a big list of new features, but which ones are the most important to stakeholders? You have a few breaking changes, which are likely to have the most widespread impact? Without being judicious about what information is included, you risk overwhelming readers with line noise and burying important notes.

Some things go beyond the scope of a commit message - deployment nuance, interaction with other relases, featureset compatibility matrices. These are best summarised at the top level, they don't fit in individual disparate messages.

One of OP's motivations for starting this thread was to see how people tailor changelogs to different types of stakeholders; techincal vs non-technical, for example. This approach doesn't solve that problem. In fact, I think it's worse due to an additional side effect: the commits are now forced to do double duty; they must be useful commits for developers looking at code history, but now they also must be useful messages to be included in a changelog. While there is some overlap, it's hard to do both simultaneously. One must pick between writing good commit messages for the codebase & developers, versus writing a coherent changelog.

As a matter of personal taste, I think it looks lazy. Changelogs are a unique opportunity to communicate something important, they're written once and read by many. With a list of commits, myself and all other readers must now put in the work to find out what's relevant - it's disrespectful of others' time.
by apothegm | 2025-12-13 20:40:03+00:00
Most stakeholders only need to hear about major milestones. They don’t get release notes. They get weekly or monthly memos on what the department is accomplishing.

Unless you’re developing open source or developer APIs/SDKs, end users don’t care about release notes. The KB needs to get updated, and meaningful feature improvements get announced in newsletters or blog posts every N weeks. A good customer experience team will take care of this based on raw release notes, and also notify customers who reported bugs when those bugs are fixed.

Engineers working on the product get raw release notes.

Engineers integrating the product ideally get something edited a bit to be maximally useful when working out how to upgrade — Django’s release notes are something to aspire to.
by nmaley | 2025-12-13 20:40:14+00:00
I use Claude. It's really good, but you should try to use it as Boris suggests. The other thing I do is give it very careful and precisely worded specs for what you want it to do. I have the habit, born from long experience, of never assuming that junior programmers will know what you want the program to do unless you make it explicit. Claude is the same. LLM code generators are terrific, but they can't second guess unclear communication.

Using carefully written specs, I've found Claude will produce flawless code for quite complex problems. It's magic.
by spi | 2025-12-13 20:40:30+00:00
Yes exactly, I fear that shortening the training time would skew the results. In the very short term, smaller batch size is typically better just because you need a certain amount of gradient updates to move away from the original random, hence pretty terrible, weight distribution. Larger batch size gives a steadier, but slower, convergence, so it's hard to say for sure what is better for a given compute budget.

I'm definitely _not_ encouraging you on spending more money on a side topic just for the sake of optimizing this one parameter, there will always be another parameter after that that you'll feel an urge to optimize :-) I'd say it's already a pretty neat result to have come to a very close score to the original GPT2 training starting from scratch!

P.S. If you want to push it a bit further, rather than optimizing parameters for this model, last week at EurIPS I heard that a current "very good" modern repo to start from in order to train a good LLM is this: https://github.com/Niccolo-Ajroldi/plainLM. I haven't investigated this exactly (I'm not working on LLM), but it might be interesting to you for a sample run. The (N)EurIPS paper that was discussed at the conference claimed that the only important change to do was to modify the hyperparameters of the Adam optimizer, setting beta1=beta2=0.95 for example (the default values are beta1=0.9 and beta2=0.999 which are apparently outdated).
by godelski | 2025-12-13 20:40:36+00:00
Both you and ViewTrick have it wrong.

The tide is neither nuclear nor renewables.

The tide is "we've become advanced enough to know that there is no one-size fits all solution for energy generation and are taking a more nuanced approach to address the local and different energy needs of differing regions/grids".

I hate these online debates that frame things like "renewables vs nuclear" when the reality should be "zero-carbon emission sources vs carbon emission". The only part of nuclear is in that is if it should be on the table or not. But it is absolutely idiotic from that framework to take nuclear off the table because you're not saying "nuclear everywhere" you're saying "if nuclear makes more sense for this setting, then use nuclear".

Don't oversimplify things, it makes everything too complicated.
by hobofan | 2025-12-13 20:40:45+00:00
Whether you need a secondary set of release notes is almost purely a "marketing" decision, and should as much as possible be treated as such. Doing that is also usually way more effort (e.g. producing screenshots, etc.) than just writing plain release notes for a purse software engineer audience.

I think crafting good release notes (that go beyond automated release notes generated based on conventional commits, which are mostly good for bug hunting), is still a mainly manual and tedious process, though after the first few decent hand-crafted ones, the first draft can be handed off to an LLM these days.
by michaelsbradley | 2025-12-13 20:40:49+00:00
The concept of database cursor, or more generally continuation token, has been around a long time. Jumping to pub/sub is missing the mark.

You can have RPC prompt(input) return an opaque cursor, and promptNext(cursor) which returns partial output and the next cursor. As appropriate, the client could specify the desired size of output chunks along with input. The server could advertise or have documented the grace period for exhausting the cursors, but that’s not strictly necessary as it could be indicated in a promptNext(cursor) call that failed because of timeout. Transport session reuse can be handled automatically by HTTP.

When client receives output from a promptNext call it can work on updating the UI while promptNext is dispatched again in the background.
by linuxftw | 2025-12-13 20:41:00+00:00
Let's do the math:

A 64GB instance in Azure is $156.28/month reserved. That's $2.44/GB/month.

Let's say you use an extra 4GB RAM for a safety margin or laziness, and you have 50 replicas. That's $488.375 per month 'wasted'. Or $5860/year.

You'll never recoup the money it takes to get those replicas perfectly sized. Just give every app 4GB more RAM than you think it needs, and move on with your life.
by daxfohl | 2025-12-13 20:41:02+00:00
For your task, instead of a direct translation, try adding a "distillation" step in between. Have it take the raw format and distill the important parts to yaml or whatever, then take the distillation and translate that into the new format. That way you can muck with the yaml by hand before translating it back, which should make it easier to keep the intent without the spaghetti getting in the way. Then you can hand-wire any "complexities" into the resulting new code by hand, avoiding the slop it would more likely create.

It may even be worth having it write a parser/evaluator that does these steps in a deterministic fashion. Probably won't work, but maybe worth a shot. So long as it does each translation as a separate step, maybe at least one of them will end up working well enough, and that'll be a huge time saver for that particular task.
by luqtas | 2025-12-13 20:41:09+00:00
i'm not defending coal. i'm just saying that solution to energy is much more broad than the OP seems to pass on "being cheaper to destroy a coal plant and substitute with batteries and solar". i wouldn't be surprised trey sightread titles and didn't realized that it may be economical to re-use an OLD coal plant to produce solar energy but well... my last comment on this thread has it all, great book
by yearolinuxdsktp | 2025-12-13 20:41:51+00:00
Internal release notes:

* consisting of PRs merged since last release. (This is better than manually updating CHANGELOG. Do not allow direct commits to main w/o a PR.)

* internal audience is engineering, PMs, customer success & support, these do not leave the company.

* PRs can be examined for more context if needed. This is a good enough balance between noise & automation.

* If you use a working tracking system like JIRA or GitHub issues, join the PRs w/ the system to output priority and other labels (like Feature/Bug). This will help internal stakeholders quickly identify how important each line is. Sort by priority and/or group by labels.

External release notes:

* manually updated log of important changes, such as new features or other larger changes. These do not include all bug fixes.

* visible to customers.

* do not mention version numbers, only dates. You do not want to leak how often you release, or customers will start demanding release notes per version or dictating your release schedule.

When you fix bugs for customers, tell them what day/time the bug fix went live.

Obtaining set of PRs merged since last release is non-trivial, but doable.
by toomuchtodo | 2025-12-13 20:42:16+00:00
We are not, based on corporations laying off workers to reset wages downward, offshoring to India and LATAM, and it taking 6-12 months for workers to find jobs. Large US companies are making every effort to disempower workers, and they should be provided no advantages in acquiring talent when it exists domestically.

Layoff announcements top 1.1 million this year, the most since 2020 pandemic, Challenger says - https://www.cnbc.com/2025/12/04/layoff-announcements-this-ye... - December 4th, 2025

The Fed can't help America's young tech workers who are struggling to find a job - https://news.ycombinator.com/item?id=45705212 - October 2025

Millions of Workers Are Left Out of the 'Low-Hire, Low-Fire' US Job Market - https://news.ycombinator.com/item?id=45414795 - September 2025

Transcript of Chair Powell’s Press Conference - https://www.federalreserve.gov/mediacenter/files/FOMCprescon... - September 17th, 2025

https://news.ycombinator.com/item?id=45308049 (citations)

https://fred.stlouisfed.org/series/U6RATE

https://layoffs.fyi/

EDIT: @SilverElfin: I remain supportive of the idea of issuing O-1 visas to exceptional talent, if exceptional ability and achievement can be proven in an objective manner. A degree or credential does not make one exceptional (imho).
by raggi | 2025-12-13 20:42:21+00:00
Resumable “at least once” pub sub would be exactly the same architectural semantics as a more complete SSE implementation.

A server would keep a buffer of events and a cursor keyed by some kind of event id. Resuming clients would reattach on a new dissociated connection and ask to resume from a particular id.

This is what the id field in events and the last-event-id are for in the SSE specification.

A pub sub system would also not solve the described unidirectional problem.

As inference is so expensive it seems natural to add a sensible stream buffer solution in some middleware and that’s trivial to write. Hell it’s the kind of thing a one paragraph prompt would almost certainly one-shot.

The post seems to be more of a reaction to some specific situation than a meaningful commentary on the protocol or associated architectures.
by marking-time | 2025-12-13 20:42:25+00:00
About six months ago I was walking home from the grocery store in Sparks, NV and decided to stop by the local swap/meet. I had all my groceries in bags that I was carrying. During my time there I was jostled by the crowd and felt a little uncomfortable. When I got home I dumped out my groceries and found _two_ boxes of Girl Scout cookies that I didn't buy (I hadn't even seen any for sale). I had been reverse pickpocketed! I'm going to remember that for a long time :)
by abound | 2025-12-13 20:42:31+00:00
I would argue it's more important than ever to make new languages with new ideas as we move towards new programming paradigms. I think the existence of modern LLMs encourages designing a language with all of the following attributes:

- Simple semantics (e.g. easy to understand for developers + LLMs, code is "obviously" correct)

- Very strongly typed, so you can model even very complex domains in a way the compiler can verify

- Really good error messages, to make agent loops more productive

- [Maybe] Easily integrates with existing languages, or at least makes it easy to port from existing languages

We may get to a point where humans don't need to look at the code at all, but we aren't there yet, so making the code easy to vet is important. Plus, there's also a few bajillion lines of legacy code that we need to deal with, wouldn't it be cool if you could port (or at least extend it) it into some standardized, performant, LLM-friendly language for future development?