MurphyA/hacker-news huggingface dataset:
by pickle-wizard | 2025-08-22 16:36:48+00:00
He wasn't a programmer, but a big beard UNIX admin. Of everyone I've worked with in my career he has had the most influential. He taught me 2 core things.

1. Information is meant to shared. 2. Never do manually what can you write shell script to do.

I started at $MEGACORP on the help desk. One day I noticed one of our AIX servers had a volume filling up. So I send him an IM that says "Hey I noticed that the log partition on server BLAH is filling up". He immediately called me and told me that the server does partitions, but instead used logical volumes. He then spent the next two hours explain in detail how logical volume manger worked, how to manage volumes and the implications it had with our SAN. At the end of the call I made a comment that I was surprised he was sharing all this information with me. He responded that he didn't want the type of job security you get by hoarding information. He instead wanted by job security by enabling the team to preform at its best, and he believed you achieved that by sharing knowledge. That phone call was only the first of many such calls.

The second thing is that he believed in automating everything you could. Using knowledge he shared with me, I quickly automated most of my help desk duties. Because of this I started working more with the system administration team and was moved onto it after just a few months. In my 20 year career every job I've had has revolved around automation. I really enjoy it and without his influence I would have never gone down this path.
by blibble | 2025-08-22 16:37:21+00:00
> Golang makes it easy to do the dumb, wrong, incorrect thing that looks like it works 99.7% of the time. How can that be wrong? It works in almost all cases!

my favorite example of this was the go authors refusing to add monotonic time into the standard library because they confidently misunderstood its necessity

(presumably because clocks at google don't ever step)

then after some huge outages (due to leap seconds) they finally added it

now the libraries are a complete a mess because the original clock/time abstractions weren't built with the concept of multiple clocks

and every go program written is littered with terrible bugs due to use of the wrong clock

https://github.com/golang/go/issues/12914 (https://github.com/golang/go/issues/12914#issuecomment-15075... might qualify for the worst comment ever)
by bryanlarsen | 2025-08-22 16:37:29+00:00
SpaceX is an excellent example of this phenomenon. Reusable rockets were "known" to be financially infeasible because the Space Shuttle was so expensive. NASA & oldspace didn't seriously pursue reusable vehicles because the mostly reusable Space Shuttle cost so much more than conventional disposable vehicles.

Similar to how Sears didn't put their catalog online in the 90's because putting it online on Prodigy failed so badly in the 80's.
by mhink | 2025-08-22 16:37:48+00:00
Not to dispute too strongly (since I haven't used this functionality myself), but Node.js does have support for true multithreading since v12: https://nodejs.org/dist/latest/docs/api/worker_threads.html. I'm not sure what you mean by "M:1 threaded" but I'm legitimately curious to understand more here, if you're willing to give more details.

There are also runtimes like e.g. Hermes (used primarily by React Native), there's support for separating operations between the graphics thread and other threads.

All that being said, I won't dispute OP's point about "handling concurrency [...] within the language"- multithreading and concurrency are baked into the Golang language in a more fundamental way than Javascript. But it's certainly worth pointing out that at least several of the major runtimes are capable of multithreading, out of the box.
by potato3732842 | 2025-08-22 16:38:31+00:00
>Moving money around is a crime...why? It results in massive intrusiveness by government: full insight into everyone's finances, without evidence of a crime.

Because Karen is salty her teenage son's weed dealer isn't paying taxes, basically.

And then there's all the people who see these broad invasive things as a way to get at people who can't otherwise easily be caught, Al Capone and the like.

And don't forget all the idiots who see it as a means for "their guy" in government to exert control over people they don't like such as brown people without papers, uppity truckers with horns, etc.
by GuinansEyebrows | 2025-08-22 16:38:42+00:00
i don't think it contributes to the culture war to recognize that most people are not truly engaged in a collective sense, and that we are trapped within a self-reproducing system that relies on that:

"...the autocratic reign of the market economy which had acceded to an irresponsible sovereignty, and the totality of new techniques of government which accompanied this reign."

https://en.wikipedia.org/wiki/Spectacle_(critical_theory)
by astrange | 2025-08-22 16:38:45+00:00
The US doesn't outsource product development to China. Final assembly isn't product development. And in Taiwan's case TSMC is basically their only highly-advanced company like this, so I don't know if I find it very convincing. Samsung and Intel are not really that far behind either.

> You’re arguing for and against yourself.

No such thing as for or against, just things to be aware of.
by bigmattystyles | 2025-08-22 16:38:53+00:00
The worst mistakes to acknowledge and remedy for me have always been bad hiring. I’ve always been in the camp of ‘I can make this person work well’ but I’ve found myself questioning this approach. As my team has grown, bad fits are taxing. And it also is on other team members. I’ve shifted from doing ‘the right thing’ by giving people many chances before escalating to PIP, decided that I am just making it tough on myself and the rest of the team and to be quicker to start the process. But still, for me, it’s so much easier to acknowledge tech mistakes than dealing with employees not up to it for whatever reason, especially when they are good people. It becomes easier when they turn out to be difficult people though for me, it’s still hard.
by jandrewrogers | 2025-08-22 16:38:54+00:00
A mistake people make with thread-per-core (TPC) architecture is thinking you can pick and choose the parts you find convenient, when in reality it is much closer to "all or nothing". It may be worse to half-ass a TPC implementation than to not use TPC at all. However, TPC is more efficient in just about all contexts if you do it correctly.

Most developers are unfamiliar with the design idioms for TPC e.g. how to properly balance and shed load between cores.
by grues-dinner | 2025-08-22 16:39:10+00:00
The UK has been effectively a two party system anyway within living memory (Labour and Tories). Only rarely (e.g. 2010) does the token third party, the Lib Dems) get to be in coalition, and I think no one else has won anything since 1910.

In a monkey's paw moment for everyone who dislikes only having effectively two parties to choose from, this may soon be changing as Reform is poised to overtake the Tories.
by ashton314 | 2025-08-22 16:40:15+00:00
> So, go is a perfect fit for the http server (or service) usecase and in my experience there is no parallel.

Elixir handling 2 million websocket connections on a single machine back in 2015 would like to have a word.[1] This is largely thanks to the Erlang runtime it sits atop.

Having written some tricky Go (I implemented Raft for a class) and a lot of Elixir (professional development), it is my experience that Go's concurrency model works for a few cases but largely sucks in others and is way easier to write footguns in Go than it ought to be.

[1]: https://phoenixframework.org/blog/the-road-to-2-million-webs...
by joeguilmette | 2025-08-22 16:40:37+00:00
It’s really fun to be good at something.

In sports like skydiving and technical cave/wreck diving people often assume you get an adrenaline rush doing it and that’s what draws people in.

Not the case (for me at least).

Rather, when you get good enough to be competent at these there’s no adrenaline. Adrenaline is when you are operating beyond your skill level. The satisfaction comes from calm, cool, collected execution, with the knowledge and training that allows you to avoid the dangers and do something exceptional with a much lower risk profile than an outsider would assume.

It’s also fun to play with gear (toys).
by jhanschoo | 2025-08-22 16:40:37+00:00
> How complex does a mechanical transformation have to be to not be considered plagiarism, copyright infringement or parasitism?

Legally speaking, this depends from domain to domain. But consider for example extracting facts from several biology textbooks, and then delivering those facts to the user in the characteristic ChatGPT tone that is distinguishable from the style of each source textbook. You can then be quite assured that courts will not find that you have infringed on copyright.
by jen20 | 2025-08-22 16:40:39+00:00
Erlang (or Elixir) are absolutely Go replacements for the types of software where CSP is likely important.

Source: spent the last few weeks at work replacing a Go program with an Elixir one instead.

I'd use Go again (without question) but it is not a panacea. It should be the default choice for CLI utilities and many servers, but the notion that it is the only usable language with something approximating CSP is idiotic.
by Epa095 | 2025-08-22 16:40:49+00:00
And still (or maybe because?) the resulting adults in Sweeden score above e.g Korea in both numeracy and adaptive problem solving (but slightly less than Japan). The race is not about being best at 16 after all.

https://gpseducation.oecd.org/CountryProfile?plotter=h5&prim...

https://gpseducation.oecd.org/CountryProfile?plotter=h5&prim...
by kibwen | 2025-08-22 16:40:57+00:00
Have you read the article by Aaron Turon linked above? It's very informative, and if you have any questions about specific parts of it, feel free to reference them. In particular it boils down to the fact that Rust bends over backwards to avoid putting anything that requires allocation or dynamic dispatch in the core language (e.g. Rust's closures are fascinating in that they're stack-allocated, like C++'s, while also playing nicely with the borrow checker, which is quite a feat). This property extends to the current design of async, which makes async suitable for embedded devices, which is extremely cool (check out the Embassy project for the state of the art in this space).
by hereme888 | 2025-08-22 16:41:29+00:00
After single-fact memorization, concept-driven cards force retrieval of multiple related ideas and apply them to real-world critical thinking.

Examples:

- Cloze: "Swelling of the optic disc is called [c1::papilledema]"

Concept-based:

- Front: "Papilledema (optic disk swelling) - use the pathophysiology to explain what situations you would see this in generally."

- Back: "Anything causing central retinal vein drainage ↓ (e.g., high ICP or central retinal vein occlusion)."

- Extra field: """ Anything causing central retinal vein drainage ↓ (e.g., high ICP or central retinal vein occlusion) → back-up of blood into the capillaries of the optic nerve/disk → hydrostatic pressure ↑ → transudate of fluid leaking across the capillaries → optic nerve/disk swelling (optic disk swelling = papilledema).

Recall that the optic nerve (and thus the optic disk) drains into the central retinal vein, which ultimately drains into the cerebral circulation. """
by BeepInABox | 2025-08-22 16:41:39+00:00
For anyone curious, unless you are running a 'tar' binary from the stone ages, just skip the gunzip and cat invocations. Replace .gz with .xz or other well known file ending for different compression.

Examples: tar -cf archive.tar.gz foo bar # Create archive.tar.gz from files foo and bar. tar -tvf archive.tar.gz # List all files in archive.tar.gz verbosely. tar -xf archive.tar.gz # Extract all files from archive.tar.gz
by duxup | 2025-08-22 16:41:41+00:00
Agreed on bad human code > bad llm code.

Bad human code to me is at least more understandable in what it was trying to do. There's a goal you can figure out and fix it. It generally operates within the context of larger code to some extant.

Bad LLM code can be broken from start to finish in ways that make zero sense. Even worse when it re-invents the wheel and replaces massive amounts of code. Human aren't likely just make up a function or methods that don't exist and deploy it. That's not the best example as you'd likely find that out fast, but it's the kind of screw up that indicates the entire chunk of LLM code you're examining may in fact be fundamentally flawed beyond normal experience. In some cases you almost need to re-learn the entire codebase to truly realize "oh this is THAT bad and none of this code is of any value".
by ModernMech | 2025-08-22 16:41:42+00:00
Right, a machine that automates the planting of mines may make the user more productive at their job, but that doesn't really account for the time spent cleaning them up on the backend and how many limbs will be lost in the process. AI is an automated landmine planting machine.

Sure AI increases developer output, which is sometimes correlated with productivity -- but often times not. Insofar as AI is accelerating positive outcomes (we were able to write some tricky code that was blocking us), it's also accelerating the negative outcomes (we used the LLM to write 40k lines of code in an hour and no one know what any of it does). One of these things is "productive" the other is just performative work.

If "being more productive" is using an ai to write an email which is then summarized by AI on the receiving end, or students using AI to write papers which are graded by AI, or developers using AI to write code which is then reviewed by AI, then AI isn't actually making anything better.
by beala | 2025-08-22 16:41:50+00:00
Tough crowd.

fwiw, `tar xzf foobar.tgz` = "_x_tract _z_e _f_iles!" has been burned into my brain. It's "extract the files" spoken in a Dr. Strangelove German accent

Better still, I recently discovered `dtrx` (https://github.com/dtrx-py/dtrx) and it's great if you have the ability to install it on the host. It calls the right commands and also always extracts into a subdir, so no more tar-bombs.

If you want to create a tar, I'm sorry but you're on your own.
by hnlmorg | 2025-08-22 16:42:11+00:00
Really? I find the opposite is true. If I need lexical scope then I’d just write, for example

f.Close() // without defer

The reason I might want function scope defer is because there might be a lot of different exit points from that function.

With lexical scope, there’s only three ways to safely jump the scope:

1. reaching the end of the procedure, in which case you don’t need a defer)

2. A ‘return’, in which case you’re also exiting the function scope

3. a ‘break’ or ‘continue’, which admittedly could see the benefit of a lexical scope defer but they’re also generally trivial to break into their own functions; and arguably should be if your code is getting complex enough that you’ve got enough branches to want a defer.

If Go had other control flows like try/catch, and so on and so forth, then there would be a stronger case for lexical defer. But it’s not really a problem for anyone aside those who are also looking for other features that Go also doesn’t support.
by ThalesX | 2025-08-22 16:42:21+00:00
> Good for you if you consider yourself so emotionally detached from work

I am not. I enjoy doing great work and take pride in it.

> that you can let go of the fact that work relationships are still human relationships.

They are. And I get along with some people, and not as great with other people. But the people I get along with I go out usually, outside of work, whereas the ones I don't particularly vibe with are just colleagues.

> For instance, if I was your manager and truly believed what you're saying here*, I'd just give you the brass tax feedback and keep everything about the work itself.

I'm... usually in a pretty good human relationship with my peers, whether code monkeys or managers. So if you chose to keep everything about the work itself, we'd lose a part of our connection. But I wouldn't mind, I'd adapt.

Your last paragraph is a lot to unpack, especially trying to view myself objectively. But I will say that while I consider myself a person that is not afraid of their feelings; if I would come to you to address some aspect of the work to be done ("When something happens they can vocalize it appropriately allowing me to address it.") I wouldn't put a lot of emotional investment into this. This is what happened. I believe this would impact our whatever. Feel free to do with this information as you wish. At the end of the day I'm rowing in the boat as per the captain's indication.

I wonder though why you wouldn't believe that I get my emotional needs met from places outside of my direct contact with my manager. I have a great relationship with my family, with my friends, most of the times with my peers. I'm just not looking for emotional support in a manager and I'd like to think I've never been 'erratic' in the workplace.
by TheDong | 2025-08-22 16:42:25+00:00
The generics are a weak mimicry of what generics could be, almost as if to say "there we did it" without actually making the language that much more expressive.

For example, you're not allowed to write the following:

type Option[T any] struct { t *T } func (o *Option[T]) Map[U any](f func(T) U) *Option[U] { ... }

That fails because methods can't have type parameters, only structs and functions. It hurts the ergonomics of generics quite a bit.

And, as you rightly point out, the stdlib is largely pre-generics, so now there's a bunch of duplicate functions, like "strings.Sort" and "slices.Sort", "atomic.Pointer" and "atomic.Value", quite possible a sync/v2 soon https://github.com/golang/go/issues/71076, etc.

The old non-generic versions also aren't deprecated typically, so they're just there to trap people that don't know "no never use atomic.Value, always use atomic.Pointer".
by SkepticalWhale | 2025-08-22 16:43:12+00:00
My intent was just to emphasize that I’m comparing Go against writing JavaScript for the Node runtime and not in the browser, that is all, but you are correct.

Regarding Typescript, I actually am a big fan of it, and I almost never write vanilla JS anymore. I feel my team uses it well and work out the kinks with code review. My primary complaint, though, is that I cannot trust any other team to do the same, and TS supports escape hatches to bypass or lie about typing.

I work on a project with a codebase shared by several other teams. Just this week I have been frustrated numerous times by explicit type assertions of variables to something they are not (`foo as Bar`). In those cases it’s worse than vanilla JS because it misleads.
by eightysixfour | 2025-08-22 16:44:01+00:00
Never again with the SK Hynix drives. They have an issue they've ignored for years and refuse to fix that means the cache eventually fails on them, write speeds plummet, and the drive turns to shit. They recently released a firmware to fix it and it did nothing.

https://forum.level1techs.com/t/all-sk-hynix-p41-ssds-suffer...

You'll find reports from around the web of people flashing updated firmware and getting better performance for a few days or weeks, then it cuts back in half again.
Show HN: Breaking IDE silos with MCP for prompts and dev-tools
by scosman | 2025-08-22 16:44:02+00:00
There was a thread the other day about how there’s too many conflicting “standards” for where to add agent instructions to a repo (.cursorrules, AGENTS.md, etc).

I’ve got a new project which uses MCP to expose your project specific prompts (`testing-standards.md`, `design-guide.md`), and tools (`test`, `lint`, `format`, `build`) via MCP. All it takes is one YAML file to expose a custom MCP server, designed for your project.

https://github.com/scosman/hooks_mcp

- Discovery: the MCP server describes it’s functionality to your agents, both tools and prompts.

- Easy Setup: one YAML file to describe the tools (`npm check_format`) or prompts (`agents/front-end-design-guide.md`).

- Security and Speed: let your agents run some commands without approval (format, lint, etc), without granting wide open terminal access. MCP supports parallel tools for fewer chat turns.

- Portable Standard(??): MCP seems to be supported by all major agent tools. Some don’t support the ‘prompts’ feature of MCP, but for those we simply expose prompts via a `get_prompt` tool as a fallback. Also, xkcd N+1 standards joke.
by tialaramex | 2025-08-22 16:44:13+00:00
So it's true that technically the primitive type is str, and indeed it's even possible to make a &mut str though it's quite rare that you'd want to mutably borrow the string slice.

However no &str is not "an alias for &&String" and I can't quite imagine how you'd think that. String doesn't exist in Rust's core, it's from alloc and thus wouldn't be available if you don't have an allocator.
by nutjob2 | 2025-08-22 16:44:18+00:00
The better programmer you are, the better the software you're going to get using LLMs. But the worst programmers are leaning on LLMs the most.

The paradox is that the better LLMs get, the more serious the bugs will be because the software will seem ok, only to blow up after people have developed a false sense of security.
by almostgotcaught | 2025-08-22 16:44:26+00:00
> "We've made this mistake before so for consistency we need to repeat it" is such a bad idea.

no it's not. you literally have no other choice. you cannot add scopes after the fact - it is a breaking change. you cannot have some parts of the language have scopes and others not - it's so much worse for the user. think about human languages and which ones get quoted as being the hardest to learn (those with many exceptions). you're just wrong.
by mdaniel | 2025-08-22 16:44:36+00:00
Well, that's the problem I was highlighting - golang somehow decided to have the worst of both worlds: arbitrary domains in import paths and then putting the actual ref of the source code ... elsewhere

import "gopkg.in/yaml.v3" // does *what* now? curl https://gopkg.in/yaml.v3?go-get=1 | grep github <meta name="go-source" content="gopkg.in/yaml.v3 _ https://github.com/go-yaml/yaml/tree/v3.0.1{/dir} https://github.com/go-yaml/yaml/blob/v3.0.1{/dir}/{file}#L{line}">

oh, ok :-/

I would presume only a go.mod entry would specify whether it really is v3.0.0 or v3.0.1

Also, for future generations, don't use that package https://github.com/go-yaml/yaml#this-project-is-unmaintained
by NalNezumi | 2025-08-22 16:45:13+00:00
Sorry, by natives I meant Japanese Natives; A school for japanese kids (kids of japanese parents). Although I read that in Canada they recently removed that restriction, since there's now 3rd and 4th generation Canadian that teaches Japanese to the kids.

The teachers was often Japanese teachers. Usually they did teaching locally (in Sweden) or had other jobs, but most of them with a teaching license (in Japan). My Mother also did teaching there for a short time, and told me that the salary was very very low (like 300$ or something, per month) and people mostly did it for passion or part of the community thing.

I did a quick googling and right now the price seems 100$ for entering the school, and around 850$ per year. Not sure about the teachers salary now or what back then.

Other students were either: Half-Swedish/Japanese, settled in Sweden. Immigrants with both parent Japanese, settled in Sweden. Expats kids (usually in Sweden for a short time, 1-2 years, for work) both parent Japanese. The former two spoke both language, the latter only spoke Japanese.
by selecsosi | 2025-08-22 16:46:18+00:00
This is why you have to have skin in the game, and a backbone to say no to executives when it compromises delivery if there isn't escalated mediation.

Said another way, I don't say no a lot, I put prioritization up front and tell them that we are sacrificing other deliver items.

That is a decision that an exec can work with, mediate between teams, and builds mutual respect for senior leadership as you don't break promises you've already made, unless there is mutual agreement from the business.