skysight-inc/HackerNews huggingface dataset:
Have you ever been to Northern Ireland? This comment is so misinformed. You say widespread, most people don’t care anymore. It is only in the incredibly deprived estates that this matters anymore, and even then it’s mostly loyalist drug dealers terrorising their own community.

The Alliance party, the non-aligned neo-liberal party here, had a massive jump in votes in the recent election.

The idea that if the British weren’t here people would instantly devolve into sectarian murders is completely laughable to me.

In my entire life I have never interacted with anyone who was sectarian. You see the areas with union flags strung up everywhere but as I say, these communities are completely insular and run by drug dealers hiding behind the aegis of shared ethnicity.

“A mill stone around our neck”, come off it, my eyes are rolling so hard in my head I fear they may roll under the sofa
I have some, let me know which ones you like, I might have more suggestions for you!

In no particular order:

Lex Friedman podcast, lots of scientific interviews:
https://youtube.com/c/lexfridman

Crecganford, This one I discovered recently, expert in ancient and prehistoric mythology:
https://youtube.com/c/Crecganford

Isaac Arthur, science and futurism, some sci-fi, but very very stimulating:
https://youtube.com/channel/UCZFipeZtQM5CKUjx6grh54g

Matt Ferrel, weekly interesting topics, generally about coming soon scientific products (like, it’s is joe possible to do X with grapheme, how does it compare to y):
https://youtube.com/c/UndecidedMF

Joe Scott, same format, but more generalist (spaces from climate change solutions to Victorian era to urban legends):
https://youtube.com/c/joescott

Sabine Hossenfelder, an actual scientist explaining physics-related topics, her articles usually made it to top HN:
https://youtube.com/c/SabineHossenfelder
Blog
http://backreaction.blogspot.com/?m=1
This thread shows there is still a large amount of FUD around .NET and it’s community.

Folks here still think it’s Windows-only and comparable to Java. Yet latest TechEmpower benchmarks shows .net running on Linux and being faster than Go, Python, Node, and Rust.
> In the end, you write code for a compiler so from your perspective, nothing changes.

Isn't this only true if you're only using the CPU and not any of the other onboard hardware? For example, consider this small Arduino program I wrote: https://arduino.stackexchange.com/a/56595/33351

It would need to be entirely discarded and rewritten from scratch to work on any non-AVR microcontroller.
Primitive Technology, if you're like me and generally hate people talking and begging for likes.

SmarterEveryDay is probably my second favorite. Definitely a lot of talk, but really interesting random experiments and builds.
404 unfortunately
I wouldn't hire this person either if I had interviewed them.

When I think of a team player, I think of someone who recognizes that a team is composed of people with various skill-sets and being a team player is helping to enable the other teammates to grow at their job. Being a team player is about contributing to the team outside of just your code such as teaching the strategies you use, and your mental model for solving problems you face. It sounds like the author expects everyone to discuss a spec, and then go into their cave and solve the problem by themselves which seems very individualistic to me.

Overall, if you don't want to contribute to the overall growth of your team, than I wouldn't expect those teams to want to work with you either.

Maybe off topic, this article seems like it's main purpose is to drive traffic as the author is selling an ebook.
Nice to hear this! I am a big fan of screen casts as a way to do async updates inside remote teams. Tools like mmhmm an dyac are really good at this and its gives everyone a high bandwidth walkthrough of whatever you're working on however you do it so code, drawings, docs, etc works across a wide spectrum of activity. The rubber duck effects are a bonus!
BlackRock does not buy houses

https://www.blackrock.com/us/individual/insights/buying-hous...
To the many good suggestions here already I would add Tom Nicholas https://www.youtube.com/channel/UCxt2r57cLastdmrReiQJkEg

He talks about philosophy, social trends and politics (I know this can be controversial, but he does quite in depth analysis of current trends based on a philosophical background)
Mistakes I’ve made at the beginning of an incident (and how not to make them)
The dev experience is Windows only, STILL:

https://news.ycombinator.com/reply?id=32220935&goto=item%3Fi...

(Also the benchmarks are a cheat, look at the source code of C# vs the source code of Go or Java)
What Product Market Fit Feels Like
First time for everything, I guess.
Yes the robots and the boxes was the one I remembered most clearly! And also the graphics bit at the back with the shape made out of lines, I used to think that was so cool haha.
I was expecting some fun UI exploits like getting a negative bill for removing all the ingredients on a burger, and adding that up to pay for an actual burger [0], sadly nothing like that.

[0] https://www.delish.com/food-news/a27091162/mcdonalds-kiosks-...
BSD rewrote everything until nothing was from the original. Wine and reactos use an clean room design.
a dirty room design is an legal liability.
How to Configure ClickHouse SSL Connection
These children were mostly railway workers' kids. Whole purpose of it was to teach them railway jobs were cool to make them follow their parents' steps.

In the Soviet Union, and to a great extent in Russia till now, railway system is very independent from the State. It's frequently called a state within a state. It has it's own power stations, construction departments that build among other things, housing for workers, their own hospitals and even their own medical schools, it's own police, their own hotels and Black Sea resorts for workers, in the Soviet times they had even their own Gulags. It's a closed-loop system largely independent from the rest of it. So they have their own take on schooling, too.

Happened that way because after the Revolution of 1917, the state largely collapsed and was unable to do shit for at least next 6-7 years. Railway had to figure out how to work on its own.
This seems more like Yet Another Medium Article shooting fish in a barrel by describing problems with the JS ecosystem rather than an actual case for C# and .NET.
The Path of Getting Comfortable in Production
Need medicine? Try bloodletting!

In all seriousness though, it’s good to keep in mind human history and what’s natural, but unless you’re walking around barefoot on dirt paths, fasting for days at a time, and drinking unfiltered water from mountain streams, it seems kinda silly to arbitrarily draw the line there. There are plenty of modern things that work really well for humans, that may not have been natural 10,000 years ago
The trick with long lived branches is to merge upstream changes frequently so you don't fall behind and keep your branch in a mergeable state. Git was designed for code bases much larger than what most people deal with where long lived branches are just a reality.

Like the Linux kernel for example. You don't get to push half finished work with projects like that. Actually, you don't get to push at all. There is only pull. Some branches exist for many months or even years and there could be entire teams collaborating on them. The one absolute certainty you have on such branches is that there is an absolutely insane amount of upstream changes all the time. The only way to stay on top of that is to merge those changes often.

You can think of the Linux kernel git as a decentralized network of stacked branches that have a few central people pulling changes from branches they have reviewed into their own branches with the one that Linus Torvalds maintains as the ultimate branch on which releases get tagged. The vast majority of changes land to his branch via multiple layers of other people, each with their own branches and each adding their own reviews. Effectively all changes Linus Torvalds integrates are stacked. And he doesn't integrate them unless they are stacked properly with nice clean histories.

You could say, git was explicitly designed to do stacked branches at scale. So, it's kind of ironic that people are re-discovering this as a thing. It always was intended to be used like this. It's been used like that since the very beginning.
If the lack of natural light is affecting you, SAD (Seasonal Affective Disorder) lamps are easy to find.

Trying to generate sunlight that can fill a room like the sun is going to use a lot of power and generate heat. Also, the DIY youtube versions don't feel very realistic to me, it's probably a much harder (and expensive) problem to solve than just a fresnel lens.

edit: Watching another youtube video, it looks like the DIY versions are missing the "blue sky effect"
Then we get back to the problem of not having independent review, CI status, and deployability for each individual changeset. There's no amount of git competency that changes the fact that GitHub PRs operate at the branch level, not the commit level. I've actually done exactly what you say many times -- interactive rebase to clean up the commit history -- but the end result of that process is the creation of multiple "stacked" branches, solely so I can submit multiple PRs and conform with the team's expectations.
> “Pull Request” has a specific meaning in Git

Aren't "pull requests" a GitHub (and similar systems) thing? As far as I know, Git itself does not have a concept of "pull requests".
We have to acknowledge that introverts and extroverts excel at different things. It's not always the case. But it's generalizing, yes.

It's a bit like saying men are physically stronger than women on average. It shouldn't be controversial.
I (and many developers I know) would use the GitHub individual commit review system, but it has a lot of missing features which make it unreasonable to update commits in the PR. For example, if you rewrite one of the commits in a multi-commit PR, then GitHub loses the association and old comments are lost. Similarly, you can't view the diff between an old and new version of a commit.

As far as I know, Phabricator does not let you view or comment on individual commits in a code review (which I use at work). Let me know if you know differently and I might switch to doing that.

Can you advise me on running CI on each commit in the PR in GitHub? As far as I can see, it's technically possible in that you can run arbitrary code as part of your CI, but there's no convenient way to do it. (In particular, I would want to be able to view the CI runs for each individual commit, i.e. render the little checkmark/x next to each commit in GitHub, which seems like it would require a lot of integration via the API.)

One thing that often happens in a stack is the earlier commits are regularly merged into the main branch while the later commits await review. This helps to keep things in sync in a trunk-based development workflow. Is there a way to split out and merge only the earliest (reviewed and accepted) commits, and leave the later commits pending review, in a tool like GitHub?

Overall, I would like to be able to use GitHub PRs for big stacks, but there seems to be a lot of friction in doing so, to the point where it's more convenient to adopt an alternate code review tool (like Graphite) or PR management tool.
Stacked branches tend to produce repository structures that make this easy, but so do lots of other development practices. It is not related to "how to evaluate the completion of work", it's entirely about how you use the hammer.
In case anyone is interested, I did an optimized, but much more simple, Rust implementation just today[0], which is faster than the optimized implementation on my machine. No indexing into arrays of bytes, no unsafe, etc., no "code golf" measures. Of course, credit where it's due -- these are simply tweaks to Andrew Gallant's code.

Looks like idiomatic Rust, which I think is interesting. Shows there is more than one way to skin a cat.

[0]: https://github.com/kimono-koans/countwords/blob/master/rust/...
the biggest python codebase I'm personally aware of is JP Morgan's Athena and is about ~30 million LOC. Google, Youtube and Dropbox use Python extensively etc. Python being a scripting language stopped being a correct statement probably over a decade ago.
I was looking for the project farm shoutout.
Exact same thing happened. Found a bunch of old screenshots from 2000 to about 2006. So many programs you just stopped using at some point without really realizing, but seeing the screenshot immediately makes you feel like past you again, and what it was like to use your computer back then.

Especially when you see parts of a conversation with someone you didn't talk to in over a decade, or who passed away. You'd think that's what a photo would do, so I was surprised how strong of an emotional reaction screenshots can trigger. But then if you were spending 90% of your time online as a teen/early 20s it's not that surprising on a second thought.
If you can match a pin to a database of cards numbers, I can supply you with a database of all pins in existence
I don't think anyone wouldn't agree that being able to work deeply on a single async task would be a great benefit, but your reply completely ignores the issue OP brought up:

> Stacking in my personal experience usually leads to merge conflict hell as changes and PR suggestions get merged underneath you.

That's been my experience too.

And beyond the technical issues, the deeper you work on a single issue the more at risk you are of the simple issue of finding design or requirements issues in the base MR that require going a different direction and discarding the whole stack. So even if you can somehow avoid conflict issues, stacks are still dangerous.
Yes, you are correct.

But in most cases, you would use a driver and abstract away what individual registers get read/written.
The HAL can be taken from anywhere, really. Doesn't need to be avrgcc/Arduino.

The registers in the link are C macros resolving to uint8_t*, pointing to memory locations where you read/write to.
@sthatipamala and I run a channel called The Technium. We cover fringe, retro, or overlooked technologies that have a core idea that has potential to change how we do things. We talk about what the technology is, what it can do today, and what the 2nd order effects would be if it were pervasive.

We've covered Unison, Multi-modal and multi-task models, Zig, Transformers, NFTs, Semantic Web, Local-first software, etc. I think it'd be up your alley.

- Zig: https://www.youtube.com/watch?v=wie5YuzoUQI&list=PLZ8NrLhP6G...

- TLA+: https://www.youtube.com/watch?v=1drTz6GYpZU

- Unison: https://www.youtube.com/watch?v=EvJwaGHy768&list=PLZ8NrLhP6G...

- Transformers: https://www.youtube.com/watch?v=Kb0II5DuDE0&list=PLZ8NrLhP6G...

Channel: https://www.youtube.com/channel/UCl_rEKDGBw4myn0uOnPxYsg
Well, bad idea for now. If we can start storing up solar energy for the winter, then it might start making a lot of sense. The sand battery that can store thermal energy for months seems pretty interesting in this aspect.

https://www.bbc.com/news/science-environment-61996520
what an incredible addition Space X is the USA space programme. NASA was locked into a single main supplier (Boeing) prior to Elon Musk deciding to simply get involved. He's changed the payload economics with reusable rocketry and re-injected competition into what was a moribund monopoly. It's not easy to eulogise Musk these days but when the history of space flight is written, his contribution will be worth more than a chapter
Speaking to the task size point, I’ve found (via leading a number of teams and training many more team leads) it’s possible to decompose any task into smaller tasks so that every task is within a small constant factor of each other.

If it seems impossible for a given task, maybe because it’s particularly complex or has lots of unknowns, then no problem, simply create a “spike” task to research or prototype whatever you need to in order to decompose the big task into appropriately sized chunks (for your team’s idea of appropriate).

See you end up with a bunch of tasks that are all roughly the same size or are spikes of similar size, and you can have the very nice predictability and productivity that the author is speaking about.

(btw, I also agree that contact switches are never cheap for software developers, so it’s better to let them finish whatever they’re working on whenever it’s not too unreasonable to allow it)
Gell-Mann Amnesia

Out of curiosity, can you give a recent example of a video from Computerphile that was incorrect?
Article relies on a non-sequitur assumption that you should work on an entire feature start-to-finish without interruption.

What management ought to do is to split feature work into tasks of smallest granularity as possible, then schedule only those of highest priority. This is what actually reduces batch sizes. Then deciding to prioritize the work to finish a feature instead of new work for a different feature becomes a matter of discipline, not process. This is important because it allows management to stop throwing good money after bad on features that the business decided that they don't actually want anymore.

If Development doesn't deliver business value because Product can't stick to a coherent feature strategy, that's Product's fault, not Development's.
I agree. The past is useful for post-mortem, learning from, but it's too easy to yearn for it in lieu (low agency) of moving forward (high agency).
This "Ask HN" is about viewing a demo. Are you saying that you believe that nobody in Wine or ReactOS had viewed Microsoft Windows? These projects replicate detailed behaviors at the API (and below) level, never mind what you see on the screen.
Thunderf00t covers interesting topics, but last I checked his editing style was extremely obnoxious with large segments - sometimes 80%-90% - of new videos being a retelling of other videos (and too often one about Anita Sarkeesian for no reason).

Did he improve at all?
Please take a moment to remind yourself that different people are in different situations and have different social and technical constraints influencing their decisionmaking, and that people can come to different conclusions from your own for reasons other than incompetence and ignorance. I am sure you are a very smart and effective person, but that doesn't mean that you know what is best for every person in every situation.
On the more esoteric side:

https://en.m.wikipedia.org/wiki/Socionics

An interesting theory out of Ukraine most recently, which groups information into 8 distinct types, and then groups society into types by how individuals tend to band together to process the types of information.

Each type is grouped as a quadrant of society, and reach quadrant has a mission that is largely unnoticed (not consciously grokked) and automatic, and built into society at a macro structural level.

Essentially it's a very detailed soft model (high levels of internal logic organization, low levels of rigorous testing) which shows how humans run as if they are programs, and form into groups which are like larger programs.

Eventually you can change the program in yourself, in funny ways, and then in others. But it turns out that this is flirting with psychological damage. IMO this demonstrates an impressive leverage point of the general model.

Related, there is an additional component of advising people to seek out friends who generally prefer the same types of information that the seeker does, or who process the same kinds of information in similar ways. There are expected differences in some ways, but high-identification parts of the individual's program must not be blocked or else a feeling of latent unease can result.

Using the theory we can say that there is an ongoing discussion/battle on HN, between the logic-focused introverts of both the Alpha and Gamma quadrants. Nobody else from other groups is really quite that interested in HN long-term, that I can tell. :-)

The Alpha logicians are focused on not being caught dead being closed-minded. They want an idea to be new and fresh and logical. They seek social fit, and by god would they love some recognition, position, and affirmation of rational action. This has all kinds of pros and cons.

The Gamma equivalents are rather focused on being correct, and want to test/prove information objectively before they believe it. They seek effect, impression, display, and by god they want to see some businesslike efficiency around here. This has all kinds of pros and cons.

Anyway it's got lots of fun little aspects, a fun theory to play with.
It's a shame that the meaning of 'idempotent' has gotten watered down by half-assed implementations. The original NFS paper from Sun [0] claims that write operations are idempotent, but they aren't really. Not if another operation has occurred. Like in:

write '1' @ 0
write '2' @ 0
write '1' @ 0 (replayed through a duplicated packet)

the duplicated write RPC reverts the second write. Duplicated link and rename RPCs are even worse. They added a replay detection cache in the server later to prevent some common error cases, but it fails if the server reboots in the middle.

Anyway, CRDT correctness is hard enough that I'd be reluctant to trust it against an adversary who can inject replays.

[0] https://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=75...
Since it's not trivial to start a chain reaction that lasts long enough to create a sizeable explosion, unexpected (nuclear) explosions are a very unlikely failure mode for nuclear weapons.
My memory is fuzzy at this point but I'm pretty sure the command has been named `git-request-pull` as long as it's existed. It actually makes less sense on most forges since there's never an explicit pull step to apply them, assuming you use the forge to do approval.
I’m recently trying to limit my internet use to such projects - can you share any other bookmarks that you saved?
I use Rider on my Ubuntu machine and the dev experience for me, is even better than using VS2022 on Windows.
I added some Sunlike LED bulbs (the GE "sun filled" brand) to my office a few months ago. They aren't expensive, and they are nowhere near as bright as true daylight, but they do the trick.

Sunlike LED elements are available in different formats around the world:

http://www.seoulsemicon.com/en/technology/sunlike/casestudy/
> what else are you going to do

You can also change the definition of done - something I try to do when a task gets too large, spin off new sub-tasks, etc. The first feature doesn't quite work right, but the merge differential is usually smaller for tweaks or bug-fixes than it is for major initial features.

You can spend a lot time planning how best to break up your work, and sometimes you may be able to do that successfully, but often times it you are constrained not by git but by your tracking tool (jira, trac), which impose somewhat artificial sizes on code tasks....

And really that's the whole thing stacked prs or commits are trying to solve, minimize the merge differential.
PBS Spacetime is very well done; dense with info, but concise and well explained.
Unless using a /c/ formatted url skips redirects, directly using https://www.youtube.com/watc or https://www.youtube.com/wath does link to the video
They should port VS to native Macos and Linux platforms.
Diagrams are utterly meaningless.

Author apparently has never understod 'assembly line' nor knows how such things work.

Of course my analogy doesnt map to code delivery, but neither does his burgers.

Worthless
Yup, that never made sense to me, either.

There might be ways to help with that, by free trial of x amount of words etc. but this would be hard to consistently implement.

Also, there is clearly information so dense, it is way more valuable, than some shallow, mindless post.

So the creators would have to up a price for every sentence? And the readers get that information, before they read and link?

Alltogether just way too complicated and impractical.