MurphyA/hacker-news huggingface dataset:
by imtringued | 2026-02-27 10:48:26+00:00
Why am I getting the impression that it's your ego that got hurt?

If you like art, then you don't necessarily care about the process, you just want it to keep being produced. Artists obviously want to engage in their profession, because they have the passion to pursue the creation of art. Said passion is now twisted into gatekeeping.

When you take a look around the internet, you can see an incredible amount of beautiful art being made through manual processes by artists and they voluntarily publish a lot of their work for free. The cost and personal enrichment argument is pretty weak here. If anything, the causality could even go in the opposite direction: Artists might want to earn money to pursue their passion.

Let's be honest for a second here. It's legitimate to feel that human created art is expensive and cost prohibitive for your particular needs. Art for professional or personal purposes is usually commissioned, aka made to order, hence it cannot be a mass market commodity.

These manual processes are also inherently limited due to the fact that the entire scene (character, outfit, pose, lighting, perspective) is baked in. If there is a process that doesn't have this limitation that's great, but if the lifting of limitations in one area isn't enough to counteract the loss in quality in other areas that the manual process didn't use to run into? Suddenly that is gate keeping even though the issue at hand is that the quality isn't good enough yet?

There's also an obvious parallel to frameworks and libraries in software development. If the software ecosystem lacks flexibility and customizability or has the wrong abstraction for the problem at hand, you will need to drop down a layer and do things the old fashioned way. A manual artist can produce a character template, a set of clothes or a background design from scratch and combine it with the higher level tools. An AI-only artist is inherently limited in that regard and yet that's supposed to be the future?
by ben_w | 2026-02-27 10:48:34+00:00
I mean your own words up-thread:

> I want to live. And if you threaten my life, I will defend myself with whatever means I have at my disposal. It makes no difference whether you threaten me by taking away my livelihood or by withholding it from me. You therefore have a choice. Either you value my life as you value your own, or there will be war between us. And that is a war you will not win, because you are not only waging it against me, but against all people whose right to life you wish to deny.

Like, OK, is that just you blowing off steam or do you have a specific threshold where you'll do anything?
by jaen | 2026-02-27 10:48:50+00:00
There isn't any attempt to falsify the "clean room" claim in the article - a rational approach would be to not provide any documents about the Z80 and the Spectrum, and just ask it to one-shot an emulator and compare the outputs...

If the one-shot output resembles anything working (and I am betting it will), then obviously this isn't clean room at all.
by akoboldfrying | 2026-02-27 10:48:56+00:00
> My partner doesn't have extremely disproportionate leverage over me

This is the most... hinged... thing you said. I totally agree that bargaining power is usually far more skewed in the employment case. I think unequal bargaining power is the root of much unfairness in the world, and that the only way to really counteract this is through organising, i.e., unionisation. It's far from a panacea, mind you.

With all that said: Fundamentally, I don't think that an employer should be obligated to employ someone indefinitely. If you do: Think about whether regulations enforcing this would make an employer more likely, or less likely, to hire someone they are on the fence about.
by yixn_io | 2026-02-27 10:49:11+00:00
Two weeks ago I launched ClawHosters, a managed hosting platform for OpenClaw (open-source AI agent framework). 50 paying customers so far. Here's the technical post-mortem.

The stack: Hetzner VPS provisioning from snapshots, 5-layer Traefik routing with Redis provider, Nginx reverse proxy that kept silently breaking SSE streams, Docker container isolation with a writable-layer commit strategy, and a config migration registry to handle crash loops at 2 AM.

Some highlights from the article:

- Why `proxy_buffering off` alone doesn't fix SSE through Nginx (you need a re-framing buffer)
- Docker's `cp` command silently refuses symlinks — cost me a day
- ZeroTier + `nsenter` for injecting routes into running containers without restart
- Snapshot-based provisioning: ~3 min cold, ~30s with pre-warmed pool
- Per-request LLM billing with included token allowances per tier

Built as a solo developer alongside a full-time job. The whole thing runs in a single Rails monolith.
by themafia | 2026-02-27 10:49:19+00:00
in spectrum.c

> Address bits for pixel (x, y):
> * 010 Y7 Y6 Y2 Y1 Y0 | Y5 Y4 Y3 X7 X6 X5 X4 X3

Which is wrong. It's x4-x0. Comment does not match the code below.

> static inline uint16_t zx_pixel_addr(int y, int col) {

It computes a pixel address with 0x4000 added to it only to always subtract 0x4000 from it later. The ZX apparently has ROM at 0x0000..0x3fff necessitating the shift in general but not in this case in particular.

This and the other inline function next to it for attributes are only ever used once.

> During the
> * 192 display scanlines, the ULA fetches screen data for 128 T-states per
> * line.

Yep.. but..

> Instead of a 69,888-byte lookup table

How does that follow? The description completely forgets to mention that it's 192 scan lines + 64+56 border lines * 224 T-States.

I'm bored. This is a pretty muddy implementation. It reminds me of the way children play with Duplo blocks.
Best way to hire software developer – a better way to test AI skills
by reeeesab | 2026-02-27 10:49:52+00:00
I am working on a platform for startups where they can test a candidate for its AI skills

1. user will get a problem (build a MVP or feature based on problem statement)
2. then user need to build it in vscode where he can use copilot or codex or any avaiable tool
3. uesr need to create the exact things
4. we will track everything, prompt, iteration time, token used and everthing

based on it we will know, how much a candidate is good in AI
by sodimel | 2026-02-27 10:50:36+00:00
That's a nice project!

I searched a few comments I agreed using the "Ask HN: What are some iconic comments on HN?" thread (https://news.ycombinator.com/item?id=40719253) and I'm pleased to see some green comments here and there :)

I also made 2 QoL [fire|grease]monkey extensions for hn:

- display favicons of sites next to links: https://gist.github.com/corentinbettiol/6d9dc3a032c17ebcd94d...

- display karma next to usernames: https://gist.github.com/corentinbettiol/289503b4033a788df91f...
by mrtksn | 2026-02-27 10:50:36+00:00
What do you think it will happen once the machines fight off? Do you think that the losing side will be like "oh no our machines lost, then better we give our things to the winning machines"?

After your machines are destroyed you will be fighting machines or machines will extract and constantly optimize you. They will either exterminate you or make you busy enough not to have time for resistance. If you have something of value they will take it away. The best case scenario is to make you join the owners of the machines and keep you busy so that you don't have time to raise concerns about your 2nd class citizenship.
by VorpalWay | 2026-02-27 10:50:54+00:00
Yeah, this is a entirely different domain than what I work in (hard real-time embedded and hard real-time Linux).

Though poorly documented APIs exist everywhere, but they are not something you can rely on anyway: if it isn't documented the behaviour can change without it being a breaking change. It would be irresponsible to (intentionally) depend on undocumented behaviour. Rather you should seek to get whatever it is documented. Otherwise there is a big risk that your code will break some years down the line when someone tries to upgrade a dependency. Most software I deal with is long-lived. There is code I wrote 15 years ago that is still in production and where the code base is still evolving, and I see no reason why that wouldn't be true in another 15 years as well.

At least you should write tests to cover any dependencies on undocumented behaviour. (You do have comprehensive tests right?)
by UebVar | 2026-02-27 10:52:12+00:00
I disagree. The plug is usually part of an appliance connector cable, that has no idea what happens to be on the other side aswell. If you size that cable for the same current as the socket, the cable itself is protected by the circuit breaker.

The correct spot for the fuse is the appliance itself. Fuses used to be easily replaceable, often with fuse holders [1]. I have, however, never seen a computer with one.

[1] https://uk.farnell.com/productimages/large/en_US/4578676.jpg
by eigenspace | 2026-02-27 10:52:37+00:00
Julia has a big culture and a lot of interfaces built around writing non-allocating code. We sometimes overemphasize eliminating GC allocations from stuff.

Generally, the code ends up looking rather similar to non-GC languages. You create some buffers outside of your performance-sensitive parts, and then thread them through your code so they can be accessed and re-used in the hot loop or whatever.

It could be better, e.g. C++ and Rust both have some nice utilities for this stuff that are a bit hard to replicate in Julia, but it's not auch a huge difference, and there's also a lot of advantages on the julia side.

E.g. it's really nice to have the GC available for the non-performance critical parts of your code.
by AxiomLab | 2026-02-27 10:53:20+00:00
Demanding regulatory intervention to cure 'enshittification' is simply replacing algorithmic validation with legal validation. Both are post-facto patches on a fundamentally flawed architecture.

The reason interoperability and user sovereignty aren't hardcoded into these platforms from day one isn't a technical oversight; it's a feature of venture capital. You cannot compile a monopoly out of open protocols. Capital funds walled gardens, not axiomatic constraints.

Expecting legislation to fix runtime entropy when the compiler itself is owned by the monopolist is a fool's errand. The architecture is working exactly as designed.
by sd9 | 2026-02-27 10:53:38+00:00
Edit: sorry! I put the wrong URL in the post. It’s https://inktide.app

I've tried various reading trackers, but they felt ugly and slow, or they didn’t have my book, or they overwhelmed me.

This is a minimal reading tracker that makes room for what's important: actually reading. No social features, no reviews, no notifications. You can try it today with no account.

All data stored in localStorage, Lucene for search on OpenLibrary’s catalog.
by sethammons | 2026-02-27 10:53:44+00:00
That seems relatively straightforward, so likely incomplete: the left is a collective of various interests that often don't align internally and the right has very consistent and largely aligned interests. One of those is easier to steer. Another facet could also be education levels. As they say, a lie can get across town before the truth has its pants on. Being educated takes time and effort, and the educated lean left.
by wiredfool | 2026-02-27 10:53:50+00:00
Dutch Baby or German Pancake is probably right in that abyss.

Very eggy, with some flour/milk. It's essentially a souffle, puffs up to like 6" high in the oven. Tasty with maple syrup, powdered sugar/lemon, or just butter.

6 Eggs, 1 C flour, 1C milk.

https://www.allrecipes.com/recipe/36900/german-pancakes-ii/
by aichen_dev | 2026-02-27 10:54:04+00:00
This resonates with something I've been experimenting with. I built a small Telegram bot that summarizes articles (https://t.me/aiagentlab_bbot) and one of the most interesting parts was watching how the LLM decides what to include vs. exclude in a summary. It's the same "tool choice" problem at a micro level — the model has to choose which paragraphs are load-bearing vs. decorative.

The pattern the author describes where Claude picks tools based on vibes rather than explicit instruction matches what I see in summarization: the model develops implicit heuristics about content structure that aren't in the prompt.
by aichen_dev | 2026-02-27 10:54:20+00:00
Interesting approach to agentic workflows. I've been building something in a similar vein for text — a bot that takes article URLs and produces structured summaries autonomously (https://t.me/aiagentlab_bbot). The hardest part isn't the AI, it's the content extraction pipeline: dealing with paywalls, JavaScript-rendered content, and the sheer variety of HTML structures out there.

For video, I imagine the equivalent challenge is scene boundary detection and figuring out what constitutes a "meaningful" segment. How do you handle that?
by azan_ | 2026-02-27 10:54:47+00:00
You keep repeating it, but it’s obviously wrong in practice. I guess you can make an argument that sending WhatsApp message or generating video is just a search job but that’s not a great argument for why humans wouldn’t get replaced - it doesn’t matter if LLMs can be reduced to search tools, but if their output is good enough approximation of human worker output. If it is then it has a chance to replace human, even if you call it glorified search tool.
by aichen_dev | 2026-02-27 10:54:50+00:00
One subtlety worth mentioning: the order matters because redirections are processed left-to-right.

`command 2>&1 >file` and `command >file 2>&1` do very different things. The first duplicates stderr to wherever stdout currently points (the terminal), then redirects stdout to the file. The second redirects stdout to the file first, then duplicates stderr to wherever stdout now points (the file).

This trips up even experienced developers. The mental model that helps: think of `>&` as "make a copy of this file descriptor right now" rather than "link these together."
by SatvikBeri | 2026-02-27 10:54:54+00:00
> might not need to use a compiled language

A very minor nit: Julia is a compiled language, but it has an unusual model where it compiles functions the first time they're used. This is why highly-optimized Julia can have pretty extreme performance.

> I would say the performance is overstated by the community but out of the box it is good enough to avoid languages like C/C++ to build solutions.

For about a year we had a 2-hour problem in our hiring pipeline where the main goal was to write the fastest code possible to do a task, and the best 2 solutions were in Julia. C++ was a close third, and Rust after that.
by ForceBru | 2026-02-27 10:54:55+00:00
I found this paper (https://www.cs.uni-potsdam.de/bs/research/docs/papers/2025/l...) from around 2025 (it cites papers from 2025) which shows that the Julia version of SRAD (along with some other benchmarks) is about 5 times slower than the slowest FORTRAN implementation and consumes at least 5 times more energy, see Table 4 and Figure 1. This paper, however, doesn't seem to be peer-reviewed.
by namibj | 2026-02-27 10:54:56+00:00
See ndriscoll's answer; but besides that there should at least be a feature to tell your local app that a road in question is not to be considered private for yourself; imagine it telling you to go around a long way instead of cutting through your private driveway road that accesses your parcel from both bottom and top road, when you don't technically have the destination on your parcel (say, going to the neighbors across the bottom street straight from work which has you come by the top street first).
by VorpalWay | 2026-02-27 10:55:29+00:00
> There are some big advantages to having it in the same language.

Sure, but why not write it all in Rust or similar then? (Not writing it all in C++ I would understand.)

> This is especially nice in situations where you expect to throw away a lot of the code you write, e.g. research.

Right, that is very different from what I do. There is code I wrote 15 years ago that is still in use. And I expect the same would be true in 15 years from now. Though that is also code where a GC is a no-go entirely (the code is hard real-time).
by praptak | 2026-02-27 10:56:03+00:00
CS Lewis has a speech about the ingroups and corruption. His thesis is that the mere desire to be "in" is the greatest driver of immoral behavior:

"To nine out of ten of you the choice which could lead to scoundrelism will come, when it does come, in no very dramatic colours. Obviously bad men, obviously threatening or bribing, will almost certainly not appear. Over a drink, or a cup of coffee, disguised as triviality and sandwiched between two jokes, from the lips of a man, or woman, whom you have recently been getting to know rather better and whom you hope to know better still—just at the moment when you are most anxious not to appear crude, or naïf or a prig—the hint will come. It will be the hint of something which the public, the ignorant, romantic public, would never understand: something which even the outsiders in your own profession are apt to make a fuss about: but something, says your new friend, which “we”—and at the word “we” you try not to blush for mere pleasure—something “we always do.”"

https://www.lewissociety.org/innerring/
by scotty79 | 2026-02-27 10:58:31+00:00
There should be a checklist of simple rules of thumb that any created or reorganized entity should undergo.

For example if the organization is self-financing it breeds corruption.

If an entity mediates between buyers and sellers it can't be financed by sellers.

It should be fairly easy to compose that list by observing corrupt and underperforming setups that are already entrenched.
by VorpalWay | 2026-02-27 10:59:07+00:00
Since I don't know Julia, let me ask: how easy is it to add a use of the GC by mistake in a critical part of the code (maybe a junior dev does it)? Are there any tools to lint against that (some sort of function attribute to deny uses of GC in the function perhaps)? If it happens, how hard is it find the culript lines of code?

Because from what I have seen in other GC languages, the answers to any of those questions haven't been great.
by stopbulying | 2026-02-27 10:59:45+00:00
Cheney (Chevron, Halliburton, Kellogg Brown & Root (KBR)) did not have a qualified blind trust (QBT) while Vice President.

Cheney's office touched the presentation presented by Gen. Colin Powell which led Congress to believe that there was need to invade Iraq to save US from WMDs. Tours of duty were extended from 3 months to 24 months because "stop loss". Subsequently, the United States paid out trillions for debt-financed war and some $39 billion to Cheney's company KBR.

Today you learned that the oil company Cheney worked for (Chevron) was trying to bully Afghanistan into a pipeline deal in 1998 and also in 2001.

Cheney donated less than $10 million dollars of his Haliburton/KBR returns; mostly to a heart medicine program in his own name and retained a compensation package.
by mrpopo | 2026-02-27 11:00:17+00:00
Probably people complaining about AI today were fine with Stack Overflow before and didn't have anything to complain about back then.

I also had a better experience with Stack Overflow over AI. It's been unable to tell me that I couldn't assign a new value to my std::optional in my specific case, and kept hallucinating copy constructor rules. A Stack Overflow question matching my problem cleared that up for me.

Sometimes you need someone to tell you no.
by thevinchi | 2026-02-27 11:00:21+00:00
Autonomous weapons: agreed, not ready… yet.

Mass surveillance: Agreed… but, I do wonder how we would all feel about this topic if we were having the discussion on 9/12/2001.

The DoW just needs to wait until the next (manufactured?) crisis occurs, and not let it go to waste.

Mark my words: this will be Patriot Act++
by gjm11 | 2026-02-27 11:00:29+00:00
If you take thousands of photographs of human faces and average them out (even if you do it just by roughly aligning them, overlaying, and averaging the pixels) then what you get is a (perhaps blurry but) notably more attractive than average human face image.

LLM output could be like that. (I am not claiming that it actually is; I haven't looked carefully enough at enough of it to tell.) Humans writing code do lots of bad things, but any specific error will usually not be made.

If (1) it's correct to think of LLMs as producing something like average-over-the-whole-internet code and (2) the mechanism above is operative -- and, again, I am not claiming that either of those is definitely true -- then LLM code could be much higher quality than average, but would seldom do anything that's exceptionally good in ways other than having few bugs.
by fnands | 2026-02-27 11:00:29+00:00
Yeah, I think it's a tough one for some people. Case in point: my parents.

My father has always had a million hobbies, and his work was what was preventing him from fully exploring them. He's taken to retirement like a fish to water.

My mother on the other hand (still working at 73) like most academics has been very dedicated to her work, and her main hobby outside of work has been hiking.

I'm a little worried that she'll struggle a bit to adapt to retirement.
by evgen | 2026-02-27 11:00:58+00:00
Gelatine melts at a lower temperature and has a much better mouthfeel for most of these traditional recipes. It is creamy and adds body to a stock or sauce. Agar is brittle and requires a higher temperature to set. Agar would be a good choice for something where you want it to stay in a particular shape, but it is much more of a one-trick pony when it comes to cooking. Each can act as a poor man's version of the other, but neither really hits the same features as the other.

Agar is great for a gel, especially one you want to stand up to a bit of heat and remain stable at room temp, and I would always reach for it instead of gelatine when doing most desserts or pastry work. OTOH I would only use it in a sauce if I needed to accommodate a vegan guest.
by galdauts | 2026-02-27 11:01:24+00:00
Thank you for the article! We're mainly interested in floating-point performance and energy consumption w/r/t to solving differential equations and tridiagonal systems of equations, while running on a 128-core compute node. Our current results will likely only be presented in May, but here are last year's results: https://www.cs.uni-potsdam.de/bs/research/docs/papers/2025/l...

Our Julia code is parallelised with FLoops.jl, but so far Numba has shown surprising performance benefits when executing code in parallel, despite being slower when executed sequentially. Therefore I can imagine that Julia might yield better results when run in a regular desktop environment.
by twocommits | 2026-02-27 11:02:49+00:00
If you would make the effort to compare commits, you'll see that contributors for Co are mostly fiddling with:

- the UI (pixels here, different label or color here - just check the commits by "Yannik Bloscheck"!)

- adding objects to the map, which are not often justified (like rendering single(!) trees and tree rows, which is from a performance POV insane)

- translations / strings

They rarely touch navigation, the engine, or sensible refactoring tasks.

The whole project lacks organization and clear, structured goals. Ever heard about too many cooks?

It was, especially to the agitators like Konstantin "Pastbin", more important to obtain increased authority and power and their own branfing, while complaining about financing and perceived transparency issues; this were huge contributing factors for the split.

I couldn't give a rats about how donations are spend or if there's a "community council" or a registered entity behind a tradematk / app, if the outcome / product is suitable.

What i care about is an organized vision and structured approach by founders.

PS: The CDN middleware ("map generator") was made closed source due to too many freeloaders hogging onto their map CDN. Get your facts straight.