MurphyA/hacker-news huggingface dataset:
by erezT | 2025-12-28 21:05:12+00:00
Most people assume podcasting works like music streaming.
Someone presses play. The creator gets paid.

That’s not how it works.

Podcasts don’t get paid for listens. They get paid for ads, and only under specific conditions.
The listen has to be long enough.
The episode has to be new enough.
The ad has to actually exist.

A million listens on an old episode can generate nothing.

What surprised me digging into this wasn’t the ad model itself, but how much discovery quietly controls income.
If an episode isn’t surfaced in the short window advertisers care about, it effectively never monetizes.
Chronology matters more than popularity, but most podcast apps don’t make chronology easy to reason about across shows.

From the listener side, everything looks equal.
From the creator side, value decays fast and invisibly.

This creates a long tail of shows that feel popular but never really earn, while platforms still benefit from engagement.
by ricardonunez | 2025-12-28 21:05:50+00:00
I’m a indie developer and do marketing for my products. Build in public is a good way because building becomes the content which is the hard part. If you have an idea of your ICP, then cold outreach on LinkedIn specially if you are building and have people following you and commenting on your post. Don’t rely only in just the posts.
I recently deleted every post on my linkedin with the goal of starting building in public and following this method which is the answer to your question. I belong to a paid community of very successful bootstrapped business developers and this is what the top members do, granted they are very successful and paid people to write their content which can be time consuming.
by Natanael_L | 2025-12-28 21:05:55+00:00
There's no clear segmentation. There's symmetric and asymmetric primitives (and stuff that doesn't fit into these like ZKP), algorithms, protocols, research in many different types of attacks against each of these, research in design and defenses, and plenty of people will cover completely different subsets.

"don't" roll your own cover everything from "don't design your own primitive" to "don't make your own encryption algorithm/mode" to "don't make your own encryption protocol", to "don't reimplement an existing version of any of the above and just use an encryption library"

(and it's mostly "don't deploy your own", if you want to experiment that's fine)
by tomhallett | 2025-12-28 21:06:21+00:00
Agreed. Having a "HTML + CSS" engineer on the team was largely due to the number of hacks needed to make css work -- purposely adding invalid html that would only be parsed by specific browsers, ie5 vs ie6 vs netscape being wildly different (opera mobile was out of this world different), using sprites everywhere because additional images would have a noticeable lag time (especially with javascript hover), clearfix divs to overcome float issues. To be clear, I'm not saying "things were harder back then" or "css is simple now", but things with CSS were so wild and the tooling was so bad, that it what a unique skill of it's own that is less needed now, and the shift has been for people to focus on going deeper with js.
by toomuchtodo | 2025-12-28 21:06:29+00:00
https://en.wikipedia.org/wiki/Lou_Gerstner

https://web.archive.org/web/20251228211136/https://gerstner....

https://openlibrary.org/works/OL274413W/Who_says_elephants_c...

https://archive.org/details/WhoSaysElephantsCantDance
by docmars | 2025-12-28 21:06:39+00:00
I'm completely with you on this. Everything from scrolling to how windows behave makes a huge difference in the feeling of quality and responsiveness.

Once you're spoiled by a macOS machine's smoothness, it's hard to use anything else, where cursors feel like they're literally lagging behind your trackpad movements and land somewhere imprecise, and scrolling feels like opening a rusty car door as it catches on itself and you feel the friction.

macOS on an Apple Touchpad is like using a well-oiled machine by comparison. These things really matter!
by lvl155 | 2025-12-28 21:08:07+00:00
I hate using MacOS because they can quite literally turn off your account without recourse. I can forgive buggy and resource-intense UI. But the prospect of losing all the softwares you purchased over the years in your account simply because you wanted to use Apple-issued gift cards. That’s the most shocking anti-consumer behavior I’ve experienced in the past 40 years.
by caseysoftware | 2025-12-28 21:08:25+00:00
The intial claim/skepticism is that there were agents there at all. Proven.

Moving on to the implication and my question:

> Since the FBI primarily an investigative body (in the name) and these were NOT tacteams providing armed support, what was their purpose?

We DO deserve an explanation to that one and unfortunately, "they showed up to address the violence" doesn't resolve this because - as noted - they are NOT uniformed. Therefore, a Special Agent drawing their weapon looks like a random civilian which would only increase the chaos and danger for everyone.

They're not even particularly useful for crowd control because a) they're not uniformed and b) as an Executive agency, they don't have authority in the Capital unless US Capital Police authorizes it.. though that may take the Sergeant at Arms or the Speaker specifically, I haven't reviewed that in quite a while.

Finally, since the FBI has a multi-decade history of instigating issues to be able to stop them, we SHOULD be skeptical until we get a complete and documented explanation.
by TZubiri | 2025-12-28 21:08:27+00:00
>Rust error handling is a complex topic mostly due to the composability it gives you and no "blessed way" to accomplish this from the community.

I find it hard to believe. Since a huge class of errors are caught by compile time static analysis, you don't really need an exception system, and errors are basically just return values that you check.

It's much more productive just to use return values and check them, wrap return values in an optional, do whatever. Just move on, do not recreate the features of your previous language on a new language.
by xp84 | 2025-12-28 21:08:40+00:00
Using that option suddenly nerfed all my themes in Edge, forcing the window title bars to all be gray instead of the bold colors I use to differentiate the different profiles I use for work. I wish there was a “Reduce bullshit” toggle on MacOS and iOS, and also that it would skip all the increasingly stupid animations. No, reduce motion sucks because it just uses an equally-slow crossfade. Just STFU and let me move to the next task and stop animating everything. Good for you, you have a good GPU, I don’t care.
by roenxi | 2025-12-28 21:09:02+00:00
There are a lot of people who more discipline would help, but in many cases it seems to me that they just don't know what to do. For example, if someone lying there dying has a regret like "I wish I hadn't worked so hard" or "I wish I had let myself be happier" it is hard to say that their #1 problem is that they lacked discipline. I know a couple of people who are extremely disciplined ... at making themselves unhappy for no good reason.

I think it is more likely that a lot of people either didn't know how to relax - or potentially have internalised something about the nature of happiness that isn't true and that they can't let go of.
by burntsushi | 2025-12-28 21:09:43+00:00
> It was `std` only and linked to a concept of backtraces, which made it a non-started for embedded. It just seemed to me that it was a bad idea ever to use it in a library and that it would harm embedded users.

It was never linked to backtraces. And if you used `std::error::Error` in a library that you also wanted to support in no-std mode, then you just didn't implement the `std::error::Error` trait when the `std` feature for that library isn't enabled. Nowadays, you can just implement the `core::error::Error` trait unconditionally.

As for backtrace functionality, that is on the cusp of being stabilized via a generic interface that allows `core::error::Error` to be defined in `core`: https://github.com/rust-lang/rust/issues/99301

> and it to this day has no built-in idea of "error accumulation".

The `Error` trait has always had this. It started with `Error::cause`. That was deprecated long ago because of an API bug and replaced with `Error::source`.

> It just felt like too much churn and each one offered barely any distinction to the previous.

I wrote about how to do error handling without libraries literally the day Rust 1.0 was published: https://burntsushi.net/rust-error-handling/

That blog did include a recommendation for `failure` at one point, and now `anyhow`, but it's more of a footnote. The blog shows how to do error handling without any dependencies at all. You didn't have to jump on the error library treadmill. (Although I will say that `anyhow` and `thiserror` have been around for a number of years now and shows no signs of going away.)

> I don't bother with implementing `std::error::Error`, because it's pointless.

It's not. `std::error::Error` is what lets you provide an error chain. And soon it will be what you can extract a backtrace from.

> I'm kind of in the downcasting-is-a-code-smell camp anyways.

I happily downcast in ripgrep: https://github.com/BurntSushi/ripgrep/blob/0a88cccd5188074de...

That also shows the utility of an error chain.
by zaphar | 2025-12-28 21:09:56+00:00
If your error domain has only one useful category why not just create an error type with a useful message and be done with it. Why use anyhow at all? You are essentially saying the error domain is small so the work is tiny anyway.

anyhow seems useful in the very top layers where you basically just want bubble the useful errors modeled elsewhere to a top layer that can appropriately handle them. I don't think a crate should abdicate from modeling the error domain any more than they should abdicate from modeling the other types.
by therobots927 | 2025-12-28 21:09:59+00:00
I think it would do people in “western civ” a lot of good to do away with concepts like death being all that important. Or your identity for that matter. Not saying you shouldn’t try to minimize regrets but ironically a lot of regrets are generated precisely because of the scarcity mindset and egocentric / materialistic nature of our society. Get woke as soon as you can. It only gets harder as you get older.
by xgulfie | 2025-12-28 21:10:27+00:00
I bought a used thinkcentre tiny off of eBay. It's got great GPU decoding/encoding support, great driver support for all the peripherals, and can boot from an m2 NVME or a SATA drive, it has a very normal bootloader. It can even run Windows. The mostly-aluminum enclosure is very nice and well-engineered, it's easy to pop open, it has a power button. It was under $100 and makes me question why any hobbyist bothers with SBCs like these.
by lylejantzi3rd | 2025-12-28 21:10:32+00:00
The Koerner Office[0]. I have a lot to learn about all facets of business and Chris does a good job of keeping things practical and simple. The episode about hummingbird food[1] in particular blew my mind.

The Wookash Podcast[2]. Some of the best technical programming conversations I've heard in recent years.

[0]: https://www.youtube.com/@thekoerneroffice

[1]: https://www.youtube.com/watch?v=UcFBcfrmC2k

[2]: https://www.youtube.com/@WookashPodcast
by hinkley | 2025-12-28 21:10:36+00:00
I was a Java programmer out of school. My first specialization became performance. It’s the same problem with JavaScript. There’s at least an order of magnitude speed difference between using your head and just vomiting code, and probably more like a factor of forty. Then use some of the time you saved to do deep work to hit an even two orders of magnitude and it can be fast. If you’re not an idiot that is.

bcantril has an anecdote about porting some code to rust and it was way faster than he expected. After digging he found it was using btrees under the hood, which was a big part of the boost. B-trees being a giant pain in the ass to write in the donor language but a solved problem in Rust. It’s a bit like that. You move the effort around and it evens out.
by keyshapegeo99 | 2025-12-28 21:10:50+00:00
iPadOS 26 is an even bigger F-up than macOS 26, though

It's hugely embarrassing how they've had to perform a screeching U-turn in bringing back Slide Over and dock-launchable Split View with the .1 and .2 updates - lest graphic artists and others who depended upon these features left their platform in droves. This is essentially an admission that iPadOS 26's touch-based UX had precisely zero thought put into it. They do not have a clue what they're doing

There are still many, many more nonsensical UX degradations and bugs that need ironing out
by kev009 | 2025-12-28 21:11:01+00:00
Seemed like a pivotal time in IBM's history. IBM in 1993 was looking face to face with irrelevance during his tenure after mainframes being evergreen declared relics, and losing the bus wars in the PC industry. IBM in 2002 was still an interesting R&D and products company. Unfortunately the talent bleed off has been continuous from that time and neither the R&D nor the products are as astonishing versus the competition as they used to be. At least no follow on CEO has been daft enough to undercut the mainframe business so far, but they did miss the timing and limp execution on plenty of things.. POWER8 was almost perfectly positioned to be the AI interconnect and glue of choice.
by acdha | 2025-12-28 21:11:06+00:00
I’d also believe that he was able to ride his past reputation and his sponsor’s memory enough to get the commitment to ship Liquid Glass, but that gamble blew up once most reviews revolve around how they’ll probably make it less bad in an update. Apple values keeping users on current releases and this is the first one where so many experienced users and fans have been advising people to hold back. I think Dye knows he had enough capital to bull the release through but not to recover from making the story about the release about his shortcomings.
by jodrellblank | 2025-12-28 21:11:14+00:00
> "Plus by noticing things you are doing it already makes inner critic quieter, and this is THE practice to get rid of it"

This is the claim I don't believe, and wrote all that to argue the case against it.

How long until you get rid of it? If the answer is "hopefully it just magically goes away in a few years" that isn't an effective method.
by locknitpicker | 2025-12-28 21:12:18+00:00
> Ok, but sometimes you just need a single line in a finally and writing a class is more annoying

I don't think you understand.

If you need to run cleanup code whenever you need to destroy a resource, there is already a special member function designed to handle that: the destructor. Read up on RAII.

It somehow you failed to understand RAII and basic resource management, you can still use one-liners. Read up on scope guard.

If you are too lazy to learn about RAII and too lazy to implement a basic scope guard, you can use one of the many scope guard implementations around. Even Boost has those.

https://www.boost.org/doc/libs/latest/libs/scope/doc/html/sc...

So, unless you are lazy and want to keep mindlessly writing Java in ${LANGUAGE} regardless it makes sense or not, there is absolutely no reason at all to use finally in C++.
by TZubiri | 2025-12-28 21:12:34+00:00
>That feels like it really came out of nowhere, and after seeing so much code to implement what other languages have as a first-class feature (albeit with trade-offs that Rust clearly wanted to avoid), it comes across almost as a coping mechanism.

It's really not fair to compare these when most of the errors of one language are caught at compile time by the other.

It reminds me of that scene from silicon valley "Anything related to errors sounds like your area

https://youtu.be/oyVksFviJVE?si=NVq9xjd1uCnhZkPz&t=55

Can we not just agree that interpreted languages (save the Ackshually) like python and node need a more elaborate error handling system because they have more errors than compiled languages? It's not a holy war thing, I'm not on either side, in fact I use interpreted languages more than compiled languages, but it's just one of the very well-known trade-offs.

In the alternative, you would at least admit that error handling in an interpreted language is completely different than error handling in a compiled language.
by anal_reactor | 2025-12-28 21:13:25+00:00
The cycle of most products:

Step 1: company caters to a niche

Step 2: niche loves product, recommends to wider audience

Step 3: wider audience adopts product

Step 4: company switches to targeting the wider audience

Step 5: niche doesn't like product anymore, switches to a competitor

Windows is in step 5 - previously undisputed king of desktop, now an ad-infested boomer legacy system. MacOS is in step 4 - previously pricy but good solution for devs and creatives, now PITA for devs and "I would switch if it weren't for Adobe suite" for creatives, but normies think it looks pretty. Linux is in step 1 - Valve has been consistently investing in making it a viable gaming system. If you told me 10 years ago that Linux actually runs games other than TuxCart, I'd have laughed, but nowadays "does it run on Linux" is a serious question for every new release. It just needs some time to mature, and once gamers switch, other desktop users will slowly follow.
by senordevnyc | 2025-12-28 21:13:32+00:00
I’m growing a solo SaaS in a tiny niche market. In the last six months I’ve gone from zero to about $200k ARR. My average subscription price is about $250/month.

I’m not sure it’d work for your price point, but I’m running Meta ads, and then having leads schedule a call with me (no public pricing). I close them on the call (they give me their CC to start a trial). That’s worked well, though I do want to move towards a self-serve model over time.
by jll29 | 2025-12-28 21:13:37+00:00
Not just for psychological reasons!

As a scientist, it's best practice to keep a daily notebook called a "lab diary" where you document your work, e.g. details of experiments conducted, day by day.

It is sometimes important to prove when you had a particular idea (e.g. for patenting purposes or copyright lawsuits or documenting the history of a field), and it is important to keep track of the details of experiments in order to be able to reproduce them. For that latter aspect, I recommend self-documenting data nowadays, i.e. data that comes with meta-data to explain how it was derived, such as parameters used to create data in an experiment, which I often encode in POSIX filenames (e.g. <method>-n=<n>-iter=<iter>-k=<k>.eval => "randombaseline-n=20-iter=500-k=3.eval").

Of course you can maintain such a diary in the form of a plain text file, and I often do that as additional companion, but files are editable, you may lose them, and they have not much worth in terms of serving as a proof;
a paper diary with daily entries, in contrast, is telling a story that is less likely to be fake.

It also makes you accountable (in case management asks you what you did on March 3 last year, you'd open your lab diary and could say "that was when we had the meeting where we decided to cancel the XYZ project"), and you can use it to extract achievements for your annual or quarterly performance reviews from it.
by d13z | 2025-12-28 21:14:41+00:00
From -10x to 5x.

It depends a lot. I work as a web platform engineer so the datasets on some parts of what I do are limited.
For a react project, there are millions of projects, code and setups in the training data.
To create and manage a monorepo that runs on our specific infrastructure, the story is different.
Writing bash scripts to run on GitHub actions: 10x.
Ask to setup a monorepo: -3x.
Modify a specific business domain: -10x.
A couple of weeks ago I was handed a project that was the implementation of a experimentation sdk. The project was made by previous developer with Claude. I couldn't understand a thing. I had to basically start from scratch to understand all the principles of how this experimentation tool worked.
This was not fault of the previous Devs, it was a combination of reading code from a third³ person (person through an LLM) plus I'm a bottom up processor.
by akerl_ | 2025-12-28 21:14:47+00:00
> but it doesn’t actually work as a serious communication tool.

Say more. Plenty of people use Signal as a serious communication tool.

> Openwall are certainly practicioners, and they use PGP-over-email: are they commiting malpractice?

They, and other communities that use GPG-encrypted emails are LARPing, and it’s only fine because their emails don’t actually matter enough for anybody to care about compromising them.

It’s not malpractice to LARP: plenty of people love getting out their physical or digital toys and playing pretend. But if you’re telling other people that your foam shield can protect them from real threats, you are lying.
by mpyne | 2025-12-28 21:16:36+00:00
I think they pretty clearly meant 'practical best' rather than 'theoretical best'. Theoretically we could be so much better, which is why everyone is so grumpy about U.S. shipbuilding.

For 'practical best' you'd normally point people to examples of warships the U.S. actually can build without much drama, but if you try this with the Navy you're basically left with, what, the last LPD class?

10 years ago you'd call the Virginia SSNs a success, but even those have now run into construction delays due to various issues, even as the Navy needs their #1 priority (Columbia-class SSBN, also delayed) to succeed to decommission the Ohios on time.
by jeremyjh | 2025-12-28 21:16:38+00:00
I imagine this is being downvoted because it suggests consumers need to change their behavior. As the Reddit hive mind knows: corporations produce the vast majority of greenhouse gas emissions. But at the end of nearly all those supply chains are consumers, without which the enterprise would not exist.

Ultimately it is Moloch [0] who drives us here.

[0]: https://medium.com/@happybits/moloch-a-race-to-the-bottom-wh...
Show HN: FOSS multi Claude-code operator
by harlequinetcie | 2025-12-28 21:17:10+00:00
Hi all,

We decided to open source our own operator to manage multiple claude-code terminals/agents/skills

The idea is simple: create your agents, and have a lead manage them for you. We have been effectively utilizing most of our claude max subs tokens this way.

Let's know your thoughts,
https://github.com/desplega-ai/agent-swarm
PS: Why we did this? We couldn't find anything out there as flexible, and smooth to use (ie. dockerized by default).
PS2: Why did we go OSS? bc Christmas!

Cheers,
by davesmylie | 2025-12-28 21:17:31+00:00
Certainly one of the few podcasts that I've stuck with. I think I started about 15+ years ago, and I know it was running for a while before that. Can't say every episode is great (not a fan of the live shows) or every segment is great (what's that noisy), but you can't beat it for it's consistency and general interest.
by pron | 2025-12-28 21:17:50+00:00
> right after the next admin renames Dept of War back to DoD

It's never actually been renamed. They just changed the stationery and website: https://www.usa.gov/agencies/u-s-department-of-defense.

Just like how Trump called in workers to put his name on the Kennedy Center building. Changing the name requires an act of Congress: https://www.law.cornell.edu/uscode/text/20/76i