MurphyA/hacker-news huggingface dataset:
by y42 | 2026-01-24 07:30:54+00:00
First lesson: Don't fall for the Survivorsip Bias.

If you see people pulling things off, what you don't see is: People not pulling off. And they are the vast majority. They invest money and time and nothing happens.

To be more "philosophical": It's a mix of luck, talent and dedication where one can substitute the other to a certain degree.

(Sorry, I know not helpful in your current situation, but I was triggered to answer the first part of your post - best of luck however!)
by hackyhacky | 2026-01-24 07:31:44+00:00
> There's no guarantee char8_t is 8 bits either, it's only guaranteed to be at least 8 bits.

Have you read the standard? It says: "The result of sizeof applied to any of the narrow character types is 1." Here, "narrow character types" means char and char8_t. So technically they aren't guaranteed to be 8 bits, but they are guaranteed to be one byte.
by lelanthran | 2026-01-24 07:32:19+00:00
> Well then imagine if Gtk made you write `struct GtkLabel`, etc. and you saw hundreds of `struct` on the screen taking up space in heavy UI code. Sometimes abstractions are worthwhile.

TBH, in that case the GtkLabel (and, indeed, the entire widget hierarchy) should be opaque pointers anyway.

If you're not using a struct as an abstraction, then don't typedef it. If you are, then hide the damn fields.
by trhway | 2026-01-24 07:33:53+00:00
it is like for example situation with energy production 30 years ago when solar was expensive and coal was cheap. Yet the solar have been becoming more and more cheap while coal becoming more and more expensive. The same will be with a lot of mining - the cost of it on earth, including environmental costs, will be rising while space mining costs will be falling. It will take time before space mined iron would make economical sense, where is space mining things like previously mentioned iridium, etc. looks to already have economical sense, or very close to it, even today.
by microtonal | 2026-01-24 07:33:58+00:00
I feel like the needle is moving, but maybe not because of the retirement of Windows 10, but other factors:

* Proton got really good and the Steam Deck is making inroads for Linux on the desktop. We are at the point were even gaming publications start to say: you could as well run Linux.

* The disintegration of the 80-years long transatlantic alliance. This really has a lot of people thinking about their big tech dependence on the east side of the ocean (and perhaps Canada?). Currently a lot of OwnCloud pilots are being started in European universities and other organizations. I see more and more people in my country buying Fairphones, the adventurous people even with /e/OS. There seems to be more interest in the Linux desktop.

The change is not very fast yet, but awareness is increasing and the ball starts rolling.
by tolerance | 2026-01-24 07:34:12+00:00
You and I must be different kinds of readers.

I’m under the impression that this style of writing is what people wish they got when they asked AI to summarize a lengthy web page. It’s criticism and commentary. I can’t see how you missed out on the passages that add to and even correct or argue against statements made in the Hackernoon article.

In a way I can’t tell how one can believe that “re-hashing [an article], interspersed with [the blogger’s] own comments” isn’t a common blogging practice. If not then the internet made a mistake by allowing the likes of John Gruber to earn a living this way.

And trust that I enjoy a good knee-jerk “slop” charge myself. To me this doesn’t qualify a bit.
by lelanthran | 2026-01-24 07:34:38+00:00
> Meanwhile after UNIX was done at AT&T, the C language authors hardly cared for the C standard committee in regards to the C compiler supported features used in Plan 9 and Inferno, being only "mostly" compatible, followed up having a authoring role in Alef, Limbo and Go.

> I doubt most C advocates ever reflect on this.

What would be the conclusion of this reflection? Assuming you have reflected on this, what was your conclusion?
by iamflimflam1 | 2026-01-24 07:36:14+00:00
> Last year, some heads-of-engineering have been happy with my work and told me they want me leading my own team. I feel like taking up that offer, but it will look like I'm just being a spoilt sport because I didn't get my way, and really I don't even know if I can argue against that.

Take up the offer. You either step up into these roles and lead or you end up being led by someone else.
by bicepjai | 2026-01-24 07:37:14+00:00
Recently I listened to an interview with a serial SaaS startup CEO, and one piece of advice clicked for me: “Get out there, talk to your customers, and write blogs, lots of them.” It clarified why companies keep churning out blog posts, reports, “primitives,” even “constitutions”; content is a growth channel.

It also made me notice how much attention I’ve been giving these tech companies, almost as a substitute for the social media I try to avoid. I remember being genuinely excited for new posts on distill.pub the way I’d get excited for a new 3Blue1Brown or Veritasium video. These days, though, most of what I see feels like fingers-tired-from-scrolling marketing copy, and I can’t bring myself to care.
by pests | 2026-01-24 07:37:54+00:00
I'm sorry, is this an in-joke or satire or something? I can't tell really. Maybe a woosh moment, and as others have said, the GP/person you are speaking about, Walter Bright, is the creator of the D language. Maybe you didn't read your parent's post? Not saying its intentional, but it almost seems rude to keep speaking in that way about someone present in the conversation.
by croon | 2026-01-24 07:37:57+00:00
> Following your instincts instead of doing the work required to understand Prêt à Voter will lead you to that conclusion. Your instincts are wrong in this case. Neither of your claims are true. The first paragraph of the Wikipedia page makes that plain.

This is from the actual paper, not wikipedia:

> C. Audit of ballot forms
Voters may wish to check that the order of candidates
claimed to be encrypted on the right-hand side does indeed
correspond to the list printed on the left-hand side. If this
were not the case then a vote cast for one candidate may be
considered after decryption as a vote for a different candidate.
To provide such reassurance, voters may elect to ‘audit’ a
ballot form. This involves removing the left-hand side of the
ballot form, and asking the system to decrypt the candidate
list from the onion on the right-hand side. The voter can then
check that the decrypted list matches the list of candidates
printed on the left-hand side. In principle, this audit can
be carried out as often as the voter wishes. This gives the
voter confidence that the ballot forms have been correctly
constructed.

> However, the voter is not allowed to cast a vote on a
decrypted ballot form. Once the candidate list associated
with a onion is known, vote privacy, and hence resistance to
coercion and vote-selling, is lost. The audit process gives an
individual voter confidence that the ballot forms are correctly
constructed, but does not allow her to check the ballot form
that she is using to cast the vote.

What I said in GP is that you can't verify WHAT you voted for AFTER the fact, because the concept of coercion hinges on being able to threaten or pay for something the victim can provide. It's a logical proof, you can't design that away. I'm not saying it's not a valid trade-off.
by mschild | 2026-01-24 07:41:10+00:00
There are a lot of valid concerns and complaints about Proton here but one positive thing that stood out to me is the fact that you can reach an actual human being without much fuss.

The amount of companies that I pay money to for one reason or another where its almost impossible to even find a "Contact Us" page much less being actually able to respond via email is way too high.

I had to contact Proton support twice in the 2 years since being subscribed to the Family Ultimate plan. Both times the support answered quickly and provided answers that solved my issues.
by flowerthoughts | 2026-01-24 07:41:37+00:00
As a technologist, I like lane-keep assist because it feels fundamentally more right that my car by default follows the road than keeps going with the turn radius I had previously input.

Cruise control with minimum distance helps me keep a sound distance even as other cars keep packing up and reducing distances on a busy highway. My previous car (Mercedes) was great at detecting if a new car coming in front of me was accelerating, if so it didn't adjust the distance as aggressively. Much better behavior than my current Kia.

Auto-break features are sweet as they react really fast. If that can avoid deploying an airbag in my face, I'm all for it.

I agree it's a lot like managing, with six buttons just to do the above, but from a bottom-up approach, each feature has value in its own right.

> For me, if I'm already driving somewhere, and have to pay enough attention to know if an emergency is about to happen, I might as well just do the driving.

Where do you draw the line? Would you prefer not having a steering and brake servo? Would you prefer sticking out your arms instead of having flashing lights? Would you prefer feeling every bump in the road to having suspension?

To me these systems just feel like natural evolution of the car concept, something that's been going on for 120 years. What Tesla failed at was putting their heads in the clouds and hoping something awesome would eventually pop out the other end. While the established car makers did incremental improvements.
by SirMaster | 2026-01-24 07:42:48+00:00
Big one, because all those cars require you to touch and move the steering wheel every X seconds. All the ones that let you go hands free cost a subscription of around $500 a year (Ford BlueCruise, GM SuperCruise). And even those only let you use hands free mode on pre-mapped roads, typically only interstates.

Becasue most cars with lane follow still lose lock on the lane when the lines are hard to see (rains, snow, etc) or missing due to exists and other things.

Becasue most cars with lane follow fail to keep well when the turn gets too sharp.

Comma.ai lets you go completely hands free with no wheel nags. It also works just fine when there are no lane lines or poorly visible lines. It also supports lane change by signaling, and then nudging the wheel when it's clear to move.

There is also an experimental mode which stops and goes at stop signs and stop lights.

If the driver monitoring camera in the comma detects you fell asleep or something, it will slow the car down and pull over. All the stock lane keep that I have used in cars, if you fail to nudge the wheel they just disengage and you keep going at full speed in a straight line...

Then we delve into OpenPilot forks like SunnyPilot that let you do things like decouple gas/break control from steering control, so you can control the gas/brake yourself and let comma just always steer for you. Comma can also steer more aggressively in turns than any lane keep I have seen, and when it can't you will see the limit being reached on the little display so you know you will need to help out on that tight curve.

Experimental mode isn't the best all the time, and SunnyPilot allows hybrid mode which uses regular mode and dynamically switches to experimental mode for stop signs and stop lights.

With SunnyPilot it can even read your car's blind spot monitors to automatically make the lane change hen clear without you having to nudge the wheel.

Some have been playing with concepts of auto navigation too where the car will take exits and turn through intersections for you.

The comma.ai devices have 10W of compute power and the current driving models only use 1W, so there is room to scale to better models with teh current comma devices. There is also talk of supporting more cameras for side views and external GPUs addons with 100W compute for potential FSD level models.
by moomoo11 | 2026-01-24 07:43:59+00:00
How about just re-frame so that you do whatever is within your power so that you don't end up in the middle or at the bottom?

Why not just aim to be near the top? You don't need to be top dog, but you can at least be in the top 10% which is doable if you're able to post on HN.

You know if you just look at the last even like 200 years people have been through like 100x worse shit, let alone the last 2000.

This is just how life is, there will always be massive disruptions.
by raffraffraff | 2026-01-24 07:44:09+00:00
For me it's not arbitrary. An android device is a general purpose handheld touchscreen computer that happens to be used for music. That means a bunch of things to me:

1. "Touchscreen first" UX

2. Heavier than it needs to be

3. Worse battery life compared to a non-Android device

Using a touchscreen in the rain is impossible. Running out of battery sucks. Going for a run with a 240g brick is no fun, it'll pull your pants down to your knees and trip you.

Compare the specs:

Hiby R1
Dimensions: 86.9 x 60.6 x 14.5 mm
Weight: 118g
OS: HibyOS
Battery: 19 hour play time
Price: $159.00

Hiby R4
Dimensions: 129.6 x 68.3 x 18.5 mm
Weight: 231g
OS: Android 12
Battery: 11 hour play time
Price: $249

These are the things matter to me, in addition to the UX, sound quality, Bluetooth support, expandable / removable storage and sane file-based playlists.
by pjmlp | 2026-01-24 07:44:15+00:00
You missed the other take, with AI assisted coding, you can stay in C++, as it will take care everything is coded with enough care.

Or why bother with Rust, when the LLM gets to generate C++ code with best practices.

While I like Rust, I think AI as the next abstraction step in programming has kind of taken its relevance away, when computer assisted programming is part of the workflow.
by BoorishBears | 2026-01-24 07:44:28+00:00
Funny, reading your comment I had the idle thought: I mostly really see callousness towards artists coming from people retaliating after being belittled by artists for using AI

And here's your response to what felt like a pretty good faith response that deserved at most an equally earnest answer, and at worst no response.

Instead they got worse than no response lol.
by sph | 2026-01-24 07:44:59+00:00
We’ve invented a machine that can spew a lot of garbage out. Sure, you can sift through it to find the nuggets of gold, but the proponents of this new methodology heavily discount this additional effort. Studies seems to show that at the end of the day the benefits are minimal, despite the claims.

Once again, it is a sign of modern programming that the solution to more problems is throwing more code at it, rather than more upfront thinking that will lead to less code overall. The “work hard, not smart” crowd won this round, I guess.

The best engineer used to be the lazy one [1]. The mental effort of micromanaging a machine by explaining what you need in prose is diametrically opposite to just being lazy, sitting on a hammock, and writing directly the simplest possible solution that requires the least amount of maintenance. But sure, enjoy the 200k line vibe coded ball of mud to run ferrets and gas towns or whatever these guys do all day.

1: before dopaminergic stimulants were as widespread as today.
by yonatan8070 | 2026-01-24 07:46:11+00:00
I recently helped my GF by proofreading something she wrote, which is a primarily Hebrew (RTL) Word document with English terms like units, numbers, and unpronouncable chemical names sprinkled in.

If I had a dollar for every time MS Word failed to correctly handle the BIDI mix and put things in the wrong order, despite me reapeatedly trying different ways to fix it, I'd be richer than Microsoft.

On the contrary, Google Docs, LibreOffice, and pretty much every text box outside of MS Office can effortlessly handle BIDI mixing, all thanks the Unicode Bidirectional Algorithm [1] being widely implemented ans standardized.

[1] https://unicode.org/reports/tr9/
by seeknotfind | 2026-01-24 07:47:01+00:00
From tests/basics/levenshtein/levenshtein.cpp:

struct Ascii {
std::shared_ptr<Bool0::bool0> _a0;
std::shared_ptr<Bool0::bool0> _a1;
std::shared_ptr<Bool0::bool0> _a2;
std::shared_ptr<Bool0::bool0> _a3;
std::shared_ptr<Bool0::bool0> _a4;
std::shared_ptr<Bool0::bool0> _a5;
std::shared_ptr<Bool0::bool0> _a6;
std::shared_ptr<Bool0::bool0> _a7;
};

This is ... okay, if you like formal systems, but I wouldn't call it performant. Depending on what you are doing, this might be performant. It might be performant compared to other formally verified alternatives. It's certainly a lot nicer than trying to verify something already written in C++, which is just messy.

From theories/Mapping/NatIntStd.v:

- Since [int] is bounded while [nat] is (theoretically) infinite,
you have to make sure by yourself that your program will not
manipulate numbers greater than [max_int]. Otherwise you should
consider the translation of [nat] into [big_int].

One of the things formal verification people complain about is that ARM doesn't have a standard memory model, or CPU cache coherence is hard to model. I don't think that's what this project is about. This project is having basically provable code. They also say this in their wiki:

https://github.com/bloomberg/crane/wiki/Design-Principles#4-...

> Crane deliberately does not start from a fully verified compiler pipeline in the style of CompCert.

What this means is that you can formalize things, and you can have assurances, but then sometimes things may still break in weird ways if you do weird things? Well, that happens no matter what you do. This is a noble effort bridging two worlds. It's cool. It's refreshing to see a "simpler" approach. Get some of the benefits of formal verification without all the hassle.
by lelanthran | 2026-01-24 07:47:22+00:00
> C23 + <compiler C extensions> is hardly simpler as people advocate.

Well, certainly simpler than C++, at any rate.

I mean, just knowing the assignment rules in C++ is worthy of an entire book on its own. Understandably, the single rule of "assignment is a bitwise copy of the source variable into the destination variable" is inflexible, but at least the person reading the local code can, just from the current scope, determine whether some assignment is a bug or not!

In many ways, C++ requires global context when reading any local scope: will the correct destructor get called? Can this variable be used as an argument to a function (a lack of a copy constructor results in the bitwise copy for on stack, with the destructor for that instance running twice - once in the stack and again when the scope ends)? Is this being passed by reference (i.e. it might be modified by the function we are calling) or by value (i.e. we don't need to worry about whether `bar` has been changed after a call to `foo(bar)`).

Many programmers don't like holding lots of global scope in their head when working in some local scope. In C, all those examples above are clear in the local scope.

All programmers who prefer C over C++ have already tried C++ in large and non-trivial projects before walking away. I doubt that the reverse is true.
by austin-cheney | 2026-01-24 07:48:11+00:00
Consider the bias. The people who do imagine the death of the programmer are not people who have ever written a software application. It’s like calling for the death of the novel, and yet there are still people reading and writing books. It’s also like the death of the accountant, or the medical doctor. I don’t see MedMD eliminating the physician.

I do eventually see jobs eliminated though, why bother with React developers if AI can already write React/JSX better? It’s like any other form of industrialization. It’s the low skill/administrative jobs that are eliminated, like the many jobs eliminated by the photocopier in the 50s.
by arduanika | 2026-01-24 07:49:16+00:00
They = the people? Not precisely. Each of the perpetrators did certain things, agreed to certain things, and knew things at certain times. But I was responding to the notion in the parent that CE was just "running an investment firm" whereas SBF was running a company doing different stuff. It turned out to be all one co-mingled entity, contrary to how it was marketed. One company, and all of the main perpetrators knew things about both sides.
by SirMaster | 2026-01-24 07:49:28+00:00
Ability to decouple gas/brake control from steering, so you can control gas/brake yourself and let comma steer at all times. With OpenPilot, when you touch the gas/brake, the steering also stops.

Ability for the comma to read your car's blind spot monitors and automatically change lanes without you having to nudge the wheel.

Ability to use dynamic mode which dynamically switches between chill mode and experimental mode, so you get the best of both worlds.

Ability to fine tune many settings related to gas/brake and steering sensitivity and control that you can't play with in OpenPilot.

That's the main differences i'm aware of, but there are more.
by moth-fuzz | 2026-01-24 07:51:06+00:00
I'm a huge fan of the 'parse, don't validate' idiom, but it feels like a bit of a hurdle to use it in C - in order to really encapsulate and avoid errors, you'd need to use opaque pointers to hidden types, which requires the use of malloc (or an object pool per-type or some other scaffolding, that would get quite repetitive after a while, but I digress).

You basically have to trade performance for correctness, whereas in a language like C++, that's the whole purpose of the constructor, which works for all kinds of memory: auto, static, dynamic, whatever.

In C, to initialize a struct without dynamic memory, you could always do the following:

struct Name {
const char *name;
};

int parse_name(const char *name, struct Name *ret) {
if(name) {
ret->name = name;
return 1;
} else {
return 0;
}
}

//in user code, *hopefully*...
struct Name myname;
parse_name("mothfuzz", &myname);

But then anyone could just instantiate an invalid Name without calling the parse_name function and pass it around wherever. This is very close to 'validation' type behaviour. So to get real 'parsing' behaviour, dynamic memory is required, which is off-limits for many of the kinds of projects one would use C for in the first place.

I'm very curious as to how the author resolves this, given that they say they don't use dynamic memory often. Maybe there's something I missed while reading.
by pjmlp | 2026-01-24 07:52:17+00:00
People that keep bringing this up always miss the rationable that Google code was written initially in a C style that isn't exception safe.

Key takeaway => "Things would probably be different if we had to do it all over again from scratch."

"On their face, the benefits of using exceptions outweigh the costs, especially in new projects. However, for existing code, the introduction of exceptions has implications on all dependent code. If exceptions can be propagated beyond a new project, it also becomes problematic to integrate the new project into existing exception-free code. Because most existing C++ code at Google is not prepared to deal with exceptions, it is comparatively difficult to adopt new code that generates exceptions.

Given that Google's existing code is not exception-tolerant, the costs of using exceptions are somewhat greater than the costs in a new project. The conversion process would be slow and error-prone. We don't believe that the available alternatives to exceptions, such as error codes and assertions, introduce a significant burden.

Our advice against using exceptions is not predicated on philosophical or moral grounds, but practical ones. Because we'd like to use our open-source projects at Google and it's difficult to do so if those projects use exceptions, we need to advise against exceptions in Google open-source projects as well. Things would probably be different if we had to do it all over again from scratch."