MurphyA/hacker-news huggingface dataset:
by YeGoblynQueenne | 2025-06-02 09:55:31+00:00
I noticed this when I was TA'ing for a Prolog course at a London university. I was marking papers and it was obvious that a respectable chunk of the students on the course had simply copied from each other. I did not say anything to the course tutor, partly because I had no idea who was copying from whom, they all had the same code with the same mistakes and idiosyncracies in their papers. The year after that I TA'd again and I found the same code copied in the new year's students' papers. I looked online but I couldn't find the original source. This was before ChatGPT so an LLM wasn't the source.

The worst thing about it was that I could tell which students were really trying to do the job on their own. Most of the time their code bore all the hallmarks of a novice Prolog programmer, i.e. it was a convoluted mess that betrayed complete confusion about the language. For Prolog, this is normal and it does not indicate a student who is lazy or sloppy, only the difficult of the language. My first efforts in Prolog weren't any better. But now, the students that obviously copied from each other had papers that looked like they deserved a better mark than the ones who had obviously done the right thing and tried.

To be honest, I couldn't find it in me to give a bad mark to anyone (except for a couple of cases where the papers were basically blank where my hand was forced). I gave lots of feedback, trying to help anyone who wanted to learn, to learn, and gave them all a mark near the top 10-20%. I think the course was an elective anyway. My dad used to teach an elective course at a university and he was incredibly harsh about it, and I guess that left a sort of aversion.
by Min0taur | 2025-06-02 09:55:37+00:00
Ohhh, I never thought I'd see FCIT/lit2go mentioned on HN! I used to work in the sound booth for lit2Go, it was one of my favorite jobs. We had some wonderful vocal talent come through, and I learned much of what I know about recording/mixing from that work.The people in charge of organizing that project were diligent/earnest to the point of sainthood.

They have quite a few historic stereo-views scattered around their open source pic site, I always enjoyed browsing those with my 3d shades on:

https://etc.usf.edu/clippix/search?q=stereoview (They had more than this search would suggest; hopefully they're still around...)
by rocqua | 2025-06-02 09:55:43+00:00
I've been looking at incremental / partial formal verification based on 'assert'-like statements. Kani for rust has an interface close to what I imagine. But I'd like to use deductive verification (something like hoare / seperation logic) instead.

This means the developer gets to decide what is important enough to try to assert. It's likely the developer will need to add sub-lemma's to get the assert to be proven, and I suspect some of these will need to be in the form of 'assumptions / requirements' at the start of a function, which then need to be confirmed at all call-sites.

A big downside here is that some things you'd like to prove often don't fit into boolean expressions in the underlying language. For example, universal / existential quantifiers aren't available (but are implicit in the formal prover, so can be hacked into). You also don't have predicates for 'this address has been allocated / initialized' nor any other predicates that let you say a value is constant. Similarly, there are no temporal quantifiers available.

I'm hoping that the above is not too limiting in practice. The fact that developers already user 'assert' statements does suggest that normal boolean expressions are already valuable.
by dotdi | 2025-06-02 09:55:57+00:00
> I had become the go-to person for making things run smoothly, for fixing urgent problems, for delivering. But every time I pushed toward more strategic and ambitious directions, there was a lot of can-kicking and “let’s think about it” that went nowhere. I was incredibly useful to the organization, but not necessarily valued, and at some point, I started feeling a sense of stagnation. Compensation was good, the actual job was aligned with my interests, but that sense of being just a useful caretaker was hitting my motivation. In the end, I had to move on to another role.

this hits home, hard.
by t-writescode | 2025-06-02 09:56:00+00:00
Maybe. But the cognitive load of learning a new language (and programming correctly in that language) is real.

And even more real is the emotional stress and mental turmoil a person faces when they're required to learn something new rather than pick up something familiar. When someone has deadlines, a home life, strong demands from their boss, familiarity with build pipelines, a team full of people that they can call on, etc, it's often easier to keep the stress and confusion count lower by sticking to the familiar.

Especially when, in cases like Python with types or Java with Lombok and "just one more thing" will "fix" the rough edges or difficult scenarios that the those specific developers have. Sure it's "one more step", but it's probably a small one and one they can reason about without having to upend their entire mental model (even if in practice they might not need to).
by dopidopHN | 2025-06-02 09:57:00+00:00
I used to think that.

And then I started working for a different kind of companies.

I screen out any structure with VC money.

It means I work for company that you never heard of, but that are profitable year after year.

How? They are very careful who gets in. And they make sure everyone is actually useful. Ration manager to worker is really really low.

Oh, and they build a product with the intends of selling it. Crazy, I know.
by anthk | 2025-06-02 09:58:10+00:00
I would love an ncurses battle simulator where you would choose the monsters with perfect EV and IV's (maxed stats) with any attack the monster supports (either by level or TM's) and you would just fight against a series of trainers a la Battle Tower or similar.

You would get the actual fun of Pokémon battles without grinding. And, yes, I know emulators with fast forward and so on, but even Pokémon Radical Red has mechanics on purpose to send grinding to /dev/null with dumb battles against Audinos in order to get EXP like craze.

BTW, Pokémon Unbound might be the best hackrom ever because of the environment and features, but when you just want to fight, an straight offline simulator would be much better.
by Aldipower | 2025-06-02 09:58:28+00:00
You always want latency or jitter as low as possible. Latency adds up in the chain. Instrument/Sequencer (2ms) -> Some digital effect (3ms) -> Digital Mixer (3ms) -> In-Ear monitor bridges an air gap with processing (6ms) Suddenly you have 14ms latency. Bad, but reality. So, every ms less is better.

Regarding jitter, this is the worst, because the brain cannot adapt to the changes, whereas constant latency can be regulated somehow by the brain.
by TuxSH | 2025-06-02 09:59:46+00:00
Don't forget <tuple> not mandated to be trivial when it can be (and in fact never being trivial with GCC's stdlib), std::print performance issues (see P3107R5, P3235R3), etc.

Heck, even std::atomic was designed with only x64 in mind (it clearly shows), and is unusable outside it. One is incentivized to write their own "atomic" class until P3330R0 is approved for RMW-centric platforms ISAs like Aarch32 and Aarch64.

And of course, Rust already has "fetch_update"...
by rocqua | 2025-06-02 10:00:02+00:00
I know of Prusti, which is made by Eth Zurich. They use a form of separation logic, their backend (viper) was initially aimed at other languages, mostly go. But now prusti is also aimed at Rust. From what I heard, Rust worked a lot better for them, because a lot of the annotation overhead of Viper was about excluding mutable aliasing. Which rust handily solves.

However, last time I checked, I think I saw that Prusti does not currently handle UnsafeCell at all. I don't think that's a fundamental limitation, just a matter prioritized development time.
by apples_oranges | 2025-06-02 10:00:20+00:00
According to this definition, being involved more, I'd rather be useful than valued. Like Socrates who went to the market to see what things he doesn't need, I cherish each meeting I am not invited to. It's a blessing.

As long as the pay is good (or better) than in the "valued" path, useful is better.

Exception: I have equity and the decisions made are bad.
by tsimionescu | 2025-06-02 10:00:50+00:00
Note that "expanding them to some number of decimal places" gives a somewhat misleading idea about how this works. What you're actually doing is computing a good enough approximation of pi, and expressing that as a decimal. But this is not the same kind of simple process that naturally gives decimals as it is for a rational fraction. Instead, you have to find some series with rational elements which converges to pi, and then compute enough terms of that series that you have a good enough approximation of pi for your purpose. Ideally, since you're interested in an inequality, you'd pick a series which is monotoniclaly increasing or decreasing, so that you know that computing more terms can't put you below or above the target number after you've reached a conclusion. But there is no canonical answer, there are numerous series which converge to pi that you could use, and they would givw you different decimal expansions as you are computing them.
by flohofwoe | 2025-06-02 10:01:40+00:00
> Houdini has been taking a few years now and VK is still 2x slower then opengl apparently

Ouch, since OpenGL isn't exactly known for being performant to begin with.

This sounds a lot like Houdini has its core rendering code designed around the granular 'state-soup model' of OpenGL and is now trying to emulate that same behaviour on top of an API which expects that all state combinations are baked upfront into immutable objects (which in some situations - especially in DCC tools - may turn out to be impossible, because they may not be able to predict all required state combinations - or the number of required state combinations is simply to large too create upfront).

There's quite recent extensions for Vulkan (VK_KHR_dynamic_rendering, VK_EXT_ extended_dynamic_state and VK_shader_object) which try to break the extreme rigidity of the Vulkan 1.0 API and go back to a more OpenGL like dynamic state soup (which IMHO is going too far, because GL's granular state soup is also its biggest problem - the best compromise is somewhere in the middle, see D3D11 or Metal) - but it might help moving code from GL to Vulkan without having to discard and create pipeline objects all the time.
by mergy | 2025-06-02 10:03:06+00:00
I like and appreciate the authors points but just wish they would have done more with the connection of the two.

You might be valued because you are many things. You might not be valued because of many things. If you are able to be useful and valued, while also being fulfilled and happy personally and professionally -- that's great.

But, there is normally not a direct and clear situation like this in organizations. If there is, enjoy it while you have it. Normally, it's not as direct and clear to assess and understand. You are also part of this equation. The dynamics in an organization are normally not consistent.

Dynamics in organizations can shift quickly. Culture can also mean you could be doing all you can but the situation is no longer good for you for a variety of reasons or good for the organization.

Informed re-evaluation of your own value in your situation, at reasonable points, is vital. You may be not as great as you think you are, you might not be able to feel valued or useful in a changed or toxic environment. You may not care about that stuff. The organization may be incapable of providing any of that validation but, ultimately, it's up to you to decide what you are able to live with and why. How the organization provides whatever for you to contemplate is part of the calculation that must rest on your shoulders -- and that effort is ongoing and important.
by modo_mario | 2025-06-02 10:03:25+00:00
>When I was one, I'd make a few exceptions each year. At the time, I was a serious competitive chess player with a well obscured tendency for occasional brilliance. But mediocrity was my primary trait. On every occasion, without failure, these carnivorous exceptions would lift my mediocrity into formidable respectability. Every time. >Killing and salivating on animals for the sake of a board game is macabre. Though it was not only chess. For me, much else is affected by the absence or presence of this mysterious substance.

I wish i could find the Huberman podcast episode again where he was interviewing some researcher or so who went over a wide host of less known compounds beneficial for the brain in some minor ways. Far too often he opened with having to disappoint the vegans or vegetarians because these were only found in (red) meat and/or fish or so.

It's been a long time since but i remember coming to the conclusion from that and some research that whilst you didn't need to eat a lot of those for it (I'd assume less than the average western diet except maybe of fatty fish) there was no way to supplement all of them and live "optimally" without em.
by YeGoblynQueenne | 2025-06-02 10:04:05+00:00
My experience is exactly the opposite. I learned so much during my degree. I also did an MSc and PhD and I learned even more there. As to employers, most did not give two rotten figs abut my degrees. They cared about culture fit and a baseline of skill, and that's it. I think some employers and senior colleagues even looked down on me for having a CS degree.
by brabel | 2025-06-02 10:04:37+00:00
I was reading that and thinking "some people are never happy". I mean, they got a nice job, nice compensation, recognition... the only thing missing, apparently, was that they were not part of the company's "strategy team"? In my experience, you can be the smartest person in the world, if the company already has a small strategy team (or top management) that is pulling all the strings and they're happy with that setup, you'll basically never be able to become a part of that, barring major changes in the company's org chart.
by jorvi | 2025-06-02 10:04:46+00:00
> Could the framework be simplified so that you don't need to learn all of it but rather just a small part when you're only doing basic stuff?

If you just want to do 'basic stuff', declarative OS management has way too much overhead.

> Couldn't pre-made configurations be made available? For example in docker it's very easy to base your image on another image from an online registry.

Nix really is as a configuration of configurations (called modules). So yes. But no one runs the exact same OS setup or container, so eventually you will need to modify it to your specification.

> This is probably the part where you really need to spend a lot of effort, but I wonder if it's possible to reduce the need for these helper functions and modularization or provide them by default for at least most common cases

Nix already has premade helper functions for common cases via 'builtins'. As far as modularization goes, at some point you are going to want to do something custom, and if you want to apply that to multiple systems then making it a module just makes sense.
by creesch | 2025-06-02 10:05:32+00:00
There is more to it. Even on different platforms there are a lot of shared APIs and principles. But yes, you still need a further understanding of the context you are now using the language in. Not to mention that you likely still need to do some further learning.

But, overall I'd say it still makes it significantly easier for someone to make a switch. Even more so given the current eco system where a front-end dev likely already has node.js installed, is somewhat familiar with npm, etc.

Even if we just stick to the syntax, just not having to worry about one such aspect when switching context overall shouldn't be understated as a benefit imho.
by alganet | 2025-06-02 10:05:36+00:00
Valued = useful + hard to find.

The more rare you are, the more you are valued. You still have to be useful to be valuable though.

In order to acquire those rare skills, an ungodly amount of work is often required. It is also a huge variable. A rare skill today can become useless tomorrow.

Also, beware of indispensable people. "This company needs me" can have all sorts of causes. Maybe you didn't documented things right, maybe you just have a long history with them. It doesn't mean being rare. Being rare is feeling "this skill I have could be of use to any similar company and few people know it".

The skill could be anything. Perfect pitch, excelent document writing, de-escalation, low-level bit shaving.
by jgrahamc | 2025-06-02 10:06:22+00:00
I just write up stuff I've done or have been working in. I try to do it in a clear manner so that others may learn something from it if they are unfamiliar with whatever it is I'm up to. And I hope that people who do know a bit about what I'm writing will make suggestions.

My latest post is exactly that: https://blog.jgc.org/2025/06/it-was-time-for-dim-bulb-curren... It's very niche, wasn't written up for SEO or whatever, and is just something I'm working on.
by tsimionescu | 2025-06-02 10:06:42+00:00
Well, 3.141 is an approximation of pi, not a representation of it, insomuch as you use it in an arithmetic expression. Of course, you can write 3.141... to just represent pi, but you can't eaisly use that in an arithmetic expression. For example, I can't tell you from "mechanical" operations if 3.141... - 3.1417 > 0, I have to lookup how big pi actually is.
by dessimus | 2025-06-02 10:07:08+00:00
Odds are the CSR's KPIs are Average Call Time and Resolution on First Contact, so as long as you give them plausible deniabilty by claiming motherboard change, it allows them to quickly resolve and close the call vs forcing you to have to call back with documentation. Besides forcing you to buy a retail license likely didn't add a nickel to their paycheck, so why start a fight with the customer that will only make the call longer and possibly require escalation.
by the_mitsuhiko | 2025-06-02 10:07:14+00:00
You are not wrong, but the issues with tar are well known. Linus himself had this to say [1]:

> Well, the fact that it hits snapshots, shows that the real problem is just "tar does stupid things that it shouldn't do".

> Yes, inode numbers used to be special, and there's history behind it. But we should basically try very hard to walk away from that broken history.

> An inode number just isn't a unique descriptor any more. We're not living in the 1970s, and filesystems have changed.

You might still get away with it most of the time today, but it's causing more and more issues.

[1]: https://lkml.iu.edu/hypermail/linux/kernel/2401.3/04127.html
by ju-bezdek | 2025-06-02 10:07:56+00:00
I’ve been working with LLMs a lot lately, and one consistent UX bottleneck is inference speed.

Many tasks follow this pattern: process small chunks → batch for inference → split results again. Parallelizing helps, but naive asyncio.gather approaches often backfire—each stage waits on the slowest batch, killing responsiveness. Mixing fast per-item logic with slower batch steps needs smarter coordination.

Technical approach: Built a pipeline library that handles the streaming coordination automatically. Uses async generators throughout with intelligent queuing for order preservation when needed.

Architecture decisions:

Stream-first design: Results flow by default, with optional collection Flexible ordering: Choose between speed (unordered) and sequence (ordered) Memory efficiency: O(batch_size) memory usage, not O(dataset_size) Backpressure handling: Automatic coordination between fast and slow stages Error boundaries: Configurable failure strategies at task level.
by Const-me | 2025-06-02 10:08:02+00:00
> probably one of the best algorithms and containers libraries in any language

Mostly agree about the algorithms. Another good thing in C++ are low-level mathematic parts of the standard library in <cmath> and <complex>.

Containers are OK, but neither usability nor performance are IMO great. Node-based containers like red-black trees and hash maps come with a contract which says pointers are stable, by default this means one malloc() per element, this is slow.

However, there’re large areas where C++ standard library is lacking.

File I/O is questionable to say the least. Networking support is missing. Unicode support is missing, <codecvt> deprecated in C++17 because they found out it no longer implements current Unicode standard and instead of fixing the standard library they dropped the support. Date and calendars support only arrived in C++/20. No built-in way to represent money amount, e.g. C# standard library has fixed-size 16 bytes type for decimal floating-point numbers, Java standard library has arbitrary-precision integers and decimals.
by red_admiral | 2025-06-02 10:08:24+00:00
And what is that judgement based on? Jobs that an AI can't do yet, like designing a system architecture and drawing boundaries (which features go in the same service), need someone with experience.

We can apply this to all points in the Future of Work section. Even the conclusion "What should you do, and why?" is basically a disguised "What domain-specific knowledge do you have to make an informed opinion on the 'why' anyway?"
by dopidopHN | 2025-06-02 10:09:08+00:00
I live in NeW Orleans. Where 90% of the housing stock is made of wood.

So the 5% French figures in 2025 confirm my impression. Most stuff are not made of wood in France.

Maybe it’s a language thing : when I say « made of wood » I mean that no stone are involved. There is no percentage. The whole frame is 2 by 4 from Home Depot.
by qprofyeh | 2025-06-02 10:09:47+00:00
Feeling valued is the key here. If you need external validation then by all means, work smarter towards it. Become a manager. Become a company influencer. Build a brand, and sell it hard.

At some point later in life, I hope you’ll figure out your own sense of value, true to your being, and decoupled from what others may grant. Your raison d'être.
by pydry | 2025-06-02 10:09:54+00:00
It doesn't matter if the running costs are minimal if the capex is sky high, the site clean up costs are sky high, the insurance costs are sky high and the lifetime is fixed.

The total cost is what matters and the total cost is absurdly expensive.

If you used a nuclear plant during its entire lifetime as a peaker at, say, an average of 50% of max capacity, the average kilowatt hour would be TEN times the cost of the average kilowatt hour sourced directly from solar panels or a wind turbine, ~7-8x the cost of the average kilowatt hour generated from gas and probably about 4-5x the cost of the average kilowatt hour sourced from solar/wind via battery/pumped storage and over 2x the cost of the average kilowatt hour from solar/wind via syngas.
by fmajid | 2025-06-02 10:10:27+00:00
There are many, many products to address this, like Mozilla's defunct Send, or the excellent but not self-hostable Wormhole.app. You will need to describe what is novel with Berb and why we should use it over other solutions, and no, using WebRTC is not sufficient.

My personal choice for this kind of situation is Wormhole-William, but it is not something my dad could use when he asks me to send the last year's worth of his granddaughter's photos to make a photobook of.