MurphyA/hacker-news huggingface dataset:
by ido | 2025-07-23 06:51:51+00:00
> When we do trunk-based development, the WIP we commit gets used, before any actual user sees it, by our whole team.

And of course internal teams love also doing QA on the side of their existing jobs ;) I think that’s fair enough to ask from developers and project/product managers but a lot of others on the team basically have to suffer lower productivity to test your code.
by globular-toast | 2025-07-23 06:53:03+00:00
Had to look up what trunk-based development is. It's where you have only one eternal integration branch, possibly longer lived release branches and short-lived feature branches.

Yes, this is the best way. Having multiple eternal branches like git flow is complete nonsense. Just don't do it. You do not need anything so ridiculous.

I joined one team that used eternal branches to deploy to various environments (staging, prod etc). What a nightmare! You could just leave a commit out of prod and be none the wiser.

With a single integration branch you either do continuous deployment to prod or you use tags to mark releases. No need for another branch. Release branches are there if you need to patch things but don't want to release everything on master. You just tag a release on the release branch.

I disagree with the linked article that says DVCS has made more branching common. Branching was never difficult, merging was. Git in particular made short lived branches a thing because now they are cheap enough to merge every day.
by lmm | 2025-07-23 06:54:35+00:00
> Which is already what you're doing in that system, and what the system is designed for.

No it isn't. The system is designed to get managers to pay for it and it does that very well, it's very ineffective at tracking or triaging issues.

> Source code is not designed to track and management issues and make sure they get prioritized, so you shouldn't be using your source code to do this.

Most things that people build systems for managing outside of the source code repo end up being less effective to manage that way.
by nineplay | 2025-07-23 06:54:53+00:00
> When we do trunk-based development, the WIP we commit gets used, before any actual user sees it, by our whole team.

I think this is where I'm stuck. I rarely work in projects where my team can 'use' the code in any meaningful way. When I wrote code for accountant my team wasn't going to be able to tell if the wash sale calculations went wonky.
by bayindirh | 2025-07-23 06:54:58+00:00
Intel released a couple of Pentium 4's from different cores topping at 3.8GHz [0].

Tom's Hardware overclocked one of these Northwood Pentium 4's to 5 GHz with liquid nitrogen and a compressor [1].

Those were the days, honestly.

[0]: https://en.wikipedia.org/wiki/Pentium_4

[1]: https://www.youtube.com/watch?v=z0jQZxH7NgM
by misja111 | 2025-07-23 06:55:07+00:00
Java can be compiled into a single binary. You can use for instance Graal VM for that: https://www.graalvm.org/latest/reference-manual/native-image...

Java has Maven and Gradle that serve as package managers. I'd say they are not any more complex than npm, except if you need complexity to do something very specific.
by DeepSeaTortoise | 2025-07-23 06:56:37+00:00
Most Germans wouldn't be able to recognize Nazism if it was doing the harlem shake on their dining table.

Mention to them that the only way Communism and Nazism differ is Nazism following Engel's nationalist approach to overthrowing capitalism rather than Marx's international one and Nazis having been obsessed with spiritual and Iranian occultism and you're met with blank stares.

Yet those are the fundamentals of Nazism everything else derives from. Including the Holocaust.

Same goes for the understanding of the Nazis "Nationalism". Most Germans just won't believe you when you tell them that it was an absurd use of that term and much more similar to the modern "pro-EU" mindset than the modern understanding of nationalism.

The Germans are propagandized into thinking the definition of Nazis is being called "rightwing" by the media and wanting decentralization of power and cultural homogenity (modern nationalism). Yet the left:

- has already its SA precursors back on the streets (Hammerbande, Antifa, "NGOs")

- is getting rid of free speech to the maximum extent they somehow can pull off within the limits of the law and beyond that through mandatory voluntary industry initiatives (e.g. "Trusted Flaggers")

- are manufacturing external enemies at fault for all wrong (the Russians)

- is spinning up the war machine (massive military spending at 5% of GDP, near limitless commitment to finance the Ukraine war instead of trying to push for peace)

- Are centralizing more and more power in the hands of highly intransparent or even unelected institutions (e.g. EU or international contracts)

And various other stuff. E.g. some of the stuff you can hear on e.g. party congresses of the German "Die Linke".
by theshrike79 | 2025-07-23 06:56:39+00:00
I always think of LLMs as offshore teams with a strong cultural aversion to saying "no".

They will do ANYTHING but tell the client they don't know what to do.

Mocking the tests so far they're only testing the mocks? Yep!

Rewriting the whole crap to do something different, but it compiles? Great!

Stopping and actually saying "I can't solve this, please give more instructions"? NEVER!
by anon-3988 | 2025-07-23 06:56:39+00:00
Granted this was years ago when I was a noob. I could not figure it out. But these days I can simply do `cargo test`, `cargo run`, and `cargo add`. I looked up what fat jar is and found this: https://stackoverflow.com/a/36539885

Seriously? This XML reminds me of the issues that I had when I first started Java, what the hell does any of these mean (yes, yes, RTFM) but then I could also just use another language and be done with it?
by ozim | 2025-07-23 06:57:46+00:00
OK it is faster as article claims but I want to see the tickets, team composition, how long they work together, team dynamics, assholes blocking PRs vs assholes pushing stuff to trunk „because they know better”.

Amount of work that was done and amount of bug reports and anyone can write that their customers are happy.

If they worked previously on PRs some numbers how that was going compared to what they do now.

For me it is just fluff and I wasted time reading it.
by toast0 | 2025-07-23 06:58:02+00:00
> The idea that you can apply lower-quality engineering practices in some systems is totally wrong, I think.

> Isn't this just another representation of the fallacy that it's possible to deliver faster by cutting quality?

If we use a real world analogy. You don't use the same engineering quality practices to build a sandwich as you do to build a space probe.

It would be a mistake to x-ray verify connections between parts in a sandwich, but it would most likely be a mistake not to for a space probe.

The engineering practice that needs to be done correctly is judging the error risk, predicting the consequences of errors, and mitigating errors where the cost of mitigation does not outweigh an estimate of the expected cost of damage from the error, including work to make things right.

If you ship a sandwich where the spread was unevenly applied, inspection likely could have detemined this before shipping, but the cost to have another person carefully review each sandwich as it is being made outweighs the cost of the ocassional dry spot on the bread... Which may not be noticed or may not be bothersome... Worst case, a sandwich can be remade.

Otoh, if an assembly comes apart in space on the way to another planet, it can't be fixed and the mission might be lost.

If it takes weeks, months, or years for changes to be deployed, it makes a lot of sense to invest in procedures that improve quality before shipping, as responding to issues is expensive.

If it takes minutes or seconds to deploy changes, measuring quality in production becomes more reasonable. Some changes are such that errors are likely to result in expensive cleanup, and those need extenstive testing before release... But things where the effects of errors will be mild can be pushed and if errors appear, a rapid response is often fine. It takes experience/wisdom to know which changes need more qualification and which are safe to try... and experience hopefully reduces errors too.
by jasonvorhe | 2025-07-23 06:58:15+00:00
Mass adoption is rarely a quality indicator. I wouldn't want to pay for the mainstream VHS model(s) when I could use Betamax (perhaps even cheaper).

A look at fandom wikis is humbling. People will persist and go very deep into stuff they care about.

In this case: Read a lot, try to build a lot, learn, learn from mistakes, compare.
by JimDabell | 2025-07-23 06:58:29+00:00
There are different flavours of TBD. Some use short-lived feature branches, some commit directly to master. The article advocates for the latter.

PRs basically have a hard-requirement on branches (or equivalent, like fork), because the code that is being requested to pull needs to be available somewhere. The article also advocates for not using pull requests.

However people who take this position also often advocate for post-merge code review. And more advocate for pair programming or mob programming, which they consider to represent code review as well. So branchless TBD isn’t incompatible with code review, just code review as it is commonly practiced.
by misja111 | 2025-07-23 06:58:32+00:00
I went the same route and am still working as a Scala dev. However Scala adoption seems to slowly go down, unfortunately .. Which is a shame because it's a beautiful language and I love using it as FP together with Cats.

However Java has advantages too: the IDE support was miles better than Scala, build times were shorter, most frameworks were more mature and better supported and the language itself was much more stable.
by otherme123 | 2025-07-23 06:58:46+00:00
There are lots of analysis you can do with a WGS, and lots of them involve a high level of expertise. But the basics are not that difficult, if you assume that you might be wrong (for example, you can try to do basic PGS for some conditions, but don't freak out if you score too high in some of them: take it as a hint worth of asking for professional guidance).

Assume you have your WGS files. BGI/Macrogen can already provide you with basic analysis (like the Variant calling), but next you can do is head to https://nf-co.re/ and look for pipelines that might be of your interest: sarek, raredisease, oncoanalyser, hlatyping... and have some fun. Next head to https://snakemake.github.io/snakemake-workflow-catalog/ and look if there is something you can be interested in (grenepipe, dna-seq-gatk-variant-calling, PopGLen...). With some help from a decent LLM you should be able to run your "admixture" that some people loves (the "I'm 3% asian, 24% african, 10% nordic..."). I don't know anyone that does à la carta analysis, we do all of them ourselves, but sure there are some.

Note that you enter a difficult world, and there is no absolutes there: is fun to play, the same way that is fun to track your own sugar levels with an app. But you shouldn't be diagnosing yourself or taking radical actions based on the results. You are not debugging yourself. Soon enough you'll be wondering about your RNA-seq under X or Y conditions.
by Frieren | 2025-07-23 06:58:57+00:00
> Note that the Pull Requests were introduced by the Open Source Software community.

"Pull requests" by that name maybe. But code reviews existed way before that. As soon as code was written, programmers started to ask for peer reviews of their code.

- Design and code inspections to reduce errors in program development. 31 December 1976. https://ieeexplore.ieee.org/document/5388086

But I guess that today's programmers think that software engineering was created in 2010.
by sfvisser | 2025-07-23 06:59:07+00:00
We use WASM quite a bit for embedding a ton of Rust code with very company specific domain code into our web frontend. Pretty cool, because now your backend and frontend can share all kinds of logic without endless network calls.

But it’s safe to say that the interaction layer between the two is extremely painful. We have nicely modeled type-safe code in both the Rust and TypeScript world and an extremely janky layer in between. You need a lot of inherently slow and unsafe glue code to make anything work. Part is WASM related, part of it wasm-bindgen. What were they thinking?

I’ve read that WASM isn’t designed with this purpose in mind to go back and forth over the boundary often. That it fits the purpose more of heaving longer running compute in the background and bring over some chunk of data in the end. Why create a generic bytecode execution platform and limit the use case so much? Not everyone is building an in-browser crypto miner.

The whole WASM story is confusing to me.
by asgraham | 2025-07-23 06:59:14+00:00
Fair enough. Cancer causation is just so weird, I'm going off the heuristic that stuff in your lungs that your lungs aren't prepared for is probably not great, especially with chronic exposure. And your lungs are really only prepared for air (which includes many things within certain tolerances [0]). The "not great" => "cancer" pipeline is really where the hand-waving comes in, and mostly far too early to tell whether the parts of vaping that are "not great" for your lungs will in fact be carcinogenic for your lungs.

So that being said, I'm mostly going to offer citations for "vaping is not great for your lungs." And that being said, I'm just going to offer citations for "specific parts of vaping are not good for your lungs." But my broader argument is that putting stuff in your lungs is going to be bad for your lungs, and these are just the most obvious ones we've found so far. Unfortunately I won't be able to find a citation for that argument.

So, first, the most recent: a study showing disposable vapes had incredibly high level of toxic metal emissions [1]. The non-disposable Juul et al variously have some concerning levels, but the insane numbers are on disposables, which are largely (entirely?) illegal in the US, at least. Still, they're not illegal everywhere, they were used heavily for several years in the US, and several of the top Google results were redditors complaining about the stupid ban and talking about how to get around it. All of this combines to lung damage down the line, and several of the toxic metals are outright carcinogenic, so lung cancer as well.

A more particular example: popcorn lung is a terrifying name, but pretty restricted risk, given the causing chemical is only in certain flavors, and those have supposedly stopped using it [2]. But again, an example of weird chemicals in your lungs cause weird things, and it'll be decades til we figure out all of them.

And finally, a study showing that vaping plus smoking leads to a four-fold higher risk of lung cancer over smoking alone (yes, they adjusted for age, gender, race, location of residence, prevalent comorbidities, and pack-years of smoking) [3].

[0] I was hoping to make a glib point about even high enough pollen concentration being bad for your lungs, but in fact a recent study suggests that allergies reduce risk of lung cancer! I'm chalking that up to allergies being your body's way of keeping non-air particulates from your lungs, but who knows. https://www.frontiersin.org/journals/medicine/articles/10.33...

[1] https://pubs.acs.org/doi/10.1021/acscentsci.5c00641

[2] Not a lot of research on popcorn lung, seemingly. Note that the name is related to its etiology, not its symptoms. https://www.summahealth.org/flourish/entries/2025/03/a-warm-...

[3] https://pubmed.ncbi.nlm.nih.gov/39210964/
Show HN: I Am 15 and Built a Dual Backend MLP from Scratch Using CUDA C++
by muchlakshay | 2025-07-23 06:59:29+00:00
hii everyone! I'm a 15-year-old and I just completed a dual backend MLP from scratch that supports both CPU and GPU (CUDA) training.

for the CPU backend, I used only Eigen for linear algebra, nothing else.

for the GPU backend, I implemented my own custom matrix library in CUDA C++. The CUDA kernels aren’t optimized with shared memory, tiling, or fused ops (so there’s some kernel launch overhead), but I chose clarity, modularity, and reusability over a few milliseconds of speedup.

that said, I've taken care to ensure coalesced memory access, and it gives pretty solid performance, around 0.4 ms per epoch on MNIST (batch size = 1000) using an RTX 3060.

This project is a big step up from my previous one. It's cleaner, well-documented, and more modular.

I’m fully aware of areas that can be improved, and I’ll be working on them in future projects. My long-term goal is to get into Harvard or MIT, and this is part of that journey.

would love to hear your thoughts, suggestions, or feedback

ive attached the link to my GitHub Repo
by _kidlike | 2025-07-23 06:59:30+00:00
I think the article misunderstood the debate... the debate is (or at least was) about gitflow, and specifically about having git branches per environment. So there are git branches for dev, staging, etc, all the way to prod. And git changes become deployed on the respective branch.

Trunk based development is about having a single master (sorry, "main"), and generating deployable artifacts from there, and then the remaining environments have only deployments of versioned artifacts.

Unless I'm missing some new debate about the value of PullRequests, but that sounds extreme.
by bayindirh | 2025-07-23 06:59:55+00:00
Both LLVM and GCC is being supported by processor manufacturers directly. Yes, Apple and Intel has their own LLVM versions, but as long as don't break compatibility with GCC and doesn't prevent porting explicitly, I don't see a problem.

I personally use GCC suite exclusively though, and while LLVM is not my favorite compiler, we can thank them for spurring GCC team into action for improving their game.
by seec | 2025-07-23 07:00:04+00:00
You got downvoted, I upvoted because I share the sentiment very strongly.

I keep getting downvoted for much less sarcastic comments that are actually providing actual information on reality.

In this case, I find it baffling that they see nothing wrong in needing 22km2 just for a solar panel installation, before even talking about the cost of batteries.

Like there is no way that this has no environmental impact and plenty of unsuspected side effects. And that's before talking about the fact that it would be an installation for just one usage, in very good conditions.

Solar is getting installed because it makes a lot of money for already rich people, there is not really any other good explanation but they'll ask the public to fund the "bad" CO2 producing installation necessary to make the whole thing viable...
by p_l | 2025-07-23 07:00:26+00:00
The funny thing is all of the above APIs? They are actually used, hell, some were used quite extensively in my memory.

It's just that we're in a bubble that does not intersect with that bubble, and a lot of the stuff became less important with always on IP connectivity and big screen smartphones with local applications and a web browser.

Some of the mentioned technologies are also used explicitly to build the actual network, especially combined with the long legacy tail involved
by astahlx | 2025-07-23 07:00:50+00:00
I see the war in Ukraine as one of them. They have huge areas of farm land, valuable in times where climate change makes farming impossible in other regions. And many big companies and countries are already invested in there. You can already see how dependent some countries are on this base on the different price spikes. (While the question remains if farm products should be traded on stock markets).
by bluetomcat | 2025-07-23 07:01:28+00:00
Yes, that was my point. Regardless of the programming language, LLMs are glorified pattern matchers. A React/Node/MongoDB address book application exposes many such patterns and they are internalised by the LLM. Even complex code like a B-tree in C++ forms a pattern because it has been done many times. Ask it to generate some hybrid form of a B-tree with specific requirements, and it will quickly get lost.
by raincole | 2025-07-23 07:01:31+00:00
Quote from the article:

> Java has been my companion through:

> Learning object-oriented programming > Building enterprise applications > Navigating the transition to cloud computing > Exploring microservices and distributed systems > Mentoring other developers > Speaking at international conferences

Yeah this is literally what 90% of senior programmers have done regardless their favorite languages. Either AI-slop or human-slop.
by pfortuny | 2025-07-23 07:01:39+00:00
After developing a wrist pain which made moving my right-hand thumb ache, I discovered the usefulness of reprogramming the home keys to tap (letter) and hold (shift-Ctrl-Alt) on my Ergodox. Also, I shifted Space and Return to the left thumb cluster.

One does indeed not need to use all the keys. Lesson learned!
by tpm | 2025-07-23 07:02:02+00:00
> In the current government, only a minority of MPs are upper class

And yet their policies are broadly right-wing conservative. Point is the government itself does not have to consist of upper-class people for the class to steer and benefit from the policies. Why is that? Well...

> The UK population leans more conservative than many other European countries

We really don't know that because the population has been massaged by right-wing propaganda for (at least) decades. I remember even in the 90's reading Financial Times or something like that and the opinion articles about the EU were quite simply lying. Can imagine it was even worse in the Daily Mail etc. The result regarding the EU is well known, but I think this applies to everything; the population seems to lean conservative because the ruling class prefers it like that and the media owners oblige.

To return to the free speech/press freedom issue, it's the same again: it only works as far as the ruling class allows that. One obvious example are the past climate and current anti-genocide protests, where the government heavily abuses anti-terrorism laws to limit free speech.

edit: from today, this: https://www.theguardian.com/world/2025/jul/23/private-eye-ca...

Stuff like this simply does not happen here.
by bayindirh | 2025-07-23 07:02:42+00:00
The newest x86_64-v1 server is older than a decade now, and I'm not sure -v2 is deprecated. RockyLinux 9 is running happily on -v2 hardware downstairs.

Oh, -v2 is deprecated for RH10. Not a big deal, honestly.

From a fleet perspective, I prefer more code uses more advanced instructions on my processors. Efficiency goes up on hot code paths possibly. What's not to love?
by globular-toast | 2025-07-23 07:03:36+00:00
Definitely feature flags are the way to go. Having those code paths integrated early doesn't cost much and makes it basically free when you want to "merge" the feature into default.

This does require your software to have a decent architecture such that feature flags aren't littering every part of your codebase, though. Ideally you want something like a whole module/plugin being enabled/disabled right at the entrypoint of your program/module. But this also pays dividends in the long run.
by bayindirh | 2025-07-23 07:05:58+00:00
>...brains are weird eh?

Yeah, certainly.

> It's quite interesting to find someone who can use the same one over and over.

I like to solve some problems once, and once I solve them sufficiently, I don't prefer to touch them, so I can focus on other things. It's not that I don't look for better solutions, but I don't actively seek them.

Same is true for tools. I prefer to master a single tool over the years to jump from tool to tool.