The C++ Killers (Not You, Rust)

https://wordsandbuttons.online/the_real_cpp_killers.html

by todsacerdoti • 2 years ago

118 115 2 years ago

sylware• 2 years ago

rv64 assembly is the new C.

bfrog• 2 years ago

C++ itself seems to be working pretty hard year after year on this task of killing C++ with endless half baked features that fail to address real problems

zabzonk13• 2 years ago

they do address real problems - specifically those of people trying to write very efficient libraries. if you are not in that group, simply don't use those features.

UncleMeat8• 2 years ago

And yet they can't update the standard library types to not be slow as hell because of ABI concerns.

If C++ was really all about speed then we'd have destructive move letting you pass unique_ptr in a register without compiler trickery. The fundamental number one constraint on new C++ behaviors is ABI compatibility. The rest is secondary.

Const-me• 2 years ago

Sadly, the C++ standard bodies are actually breaking old code in new versions of the language.

For example, C++/11 introduced UTF8 string literals. Great feature which does what you’d expect – declare a string literal in source code, get a const pointer to null-terminated array of utf-8 bytes.

Then a decade later, in C++/20 they refactored these UTF8 literals to evaluate into const pointers to the new incompatible data type, char8_t.

It’s so bad that compiler developers had to implement switches to disable the new BS. Unfortunately, these switches are incompatible across compilers, -fno-char8_t in gcc, /Zc:char8_t- in msvc.

pjmlp3• 2 years ago

They address the problems of people that care enough to show at WG21 meetings, endure the multiple rewrites of their papers, and gather as many votes as they can.

As simple as that.

Many of the modern features aren't even exposed to the comunity as preview features before being voted into the standard.

ilovefood• 2 years ago

Beautiful and well written article. Unfortunately I made a small mistake in the second quizz :P

felipellrocha• 2 years ago

The matter is, none of the languages, especially the so-called “C++ killers” give any real advantage over C++ in the modern world.

To you. There are pleeenty of people who want to write performant code in a safe manner.

WkndTriathlete• 2 years ago

To anyone.

Take C++ vs. Rust, for instance. If I look at this from a business perspective:

- Rust compiler can likely help confirm reference correctness, so this is a plus. - Rust language exchanges the cognitive load of memory allocation for tracking reference ownership, so this is a neutral. (In C++ anything that has access to the pointer can technically "own" it so there is no need to track function call traces for ownership, but lifetimes do need to be analyzed against the semantics of the program. Potato, po-tah-to.) - The pool of Rust developers available to work on a project is much smaller.

If I'm writing software where memory safety is of high importance and I can afford to take the risk with a smaller developer pool, Rust makes sense. If I'm writing a game? It's going to make far more business sense to hire a bunch of C++ developers that can work with Unreal or C# developers to work with Unity or Python developers to work with Godot or whatever.

And for real mission-critical software memory allocation isn't used so in those cases Rust has zero advantages. (Real mission-critical software lays out a static memory map up front to avoid exactly the problems Rust is trying to avoid but to also ensure real-time & predictable response times.)

So we're left with niche software like OpenSSL or similar that can benefit from Rust. But it's more likely that we want a language that supports proofs of correctness (think Coq or seL4) in those cases and Rust can't even support that.

So why choose Rust at all?

pipeline_peak• 2 years ago

None of these questions have a definite answer without context.

This is a pretty annoying thing to do considering someone took the time to read through all this.

Also not original, I’ve seen posts in here like this 3 times already

arcticbull3• 2 years ago

But why can’t I just quit then? What’s the matter? The matter is, none of the languages, especially the so-called “C++ killers” give any real advantage over C++ in the modern world. All those new languages are mostly focused on holding a programmer on a leash for their own good.

This, very specifically, is the advantage these languages have over C++.

The benefit isn't the universe of things you can do (they're all Turing complete, you can do anything) - it's what the language stops you from doing. This is the thing the C++ committee never understood or at the very least never appreciated.

zabzonk13• 2 years ago

why do you think the designers of those new languages know what is good for you?

kstrauser• 2 years ago

Because they tell me to stop managing memory by hand, as we have mountains of experiment proof that no one[0] is good at it.

[0] I meant what I said.

andyferris• 2 years ago

One thing I love about C++ is it (mostly) stops me making type errors, compared to dynamic languages - "compile and it works". Adding type constraints makes programming safer, easier, and results in better compilation.

You can add other constraints (e.g. temporal constraints) and get similar benefits, on top of the above.

dale_glass• 2 years ago

Because I believe safety critical places like aviation are the ones that actually get things right. You can't pile on every demand on the human in charge and expect improvement. We're just not great at taking every possible detail into account. Doing lots of grunt work all the time reliably is what we have computers for.

In my old age, I find the more permissive a language is, the more painful it is to code in long term. Perl is great for simple things, but C++ was a vast improvement because it catches a lot of nonsense that Perl will compile just fine.

And debugging is so expensive that eventually writing code fast is near worthless. Whatever you gain you more than pay for in debugging afterwards.

C++ unfortunately doesn't go far enough.

steveklabnik3• 2 years ago

They don’t. What they do is create a system where the system protects itself from human error. They don’t know better than me: I agree with what they’re doing. Automatic enforcement of good things, plus an escape hatch for emergencies, is better than no restrictions ever.

wk_end• 2 years ago

I assume you program in assembly language, then? Can’t trust those structured programming types to know best how to manage your instruction pointer after all. “Functions”, “loops”, “conditionals”, all just fancy words for straitjackets.

keybored2• 2 years ago

Language implementers ought to know better than me (the user) about programming language semantics, in this case specifically things like memory safety.

stavros• 2 years ago

This is a bit of a misnomer, languages don't generally stop you from doing things. They just make really damn sure that you aren't doing it by accident.

Brian_K_White• 2 years ago

what do you think those new languages prevent you from doing?

UncleMeat8• 2 years ago

Is a bounds check on every container access good for me? Not always. Sometimes my code is correct. But security vulnerabilities are observably a huge problem. And you only need one vuln in iMessage or whatever to get a dissident journalist's phone hacked and then get them murdered by the Saudi government. Is "I know what I'm doing, I promise" good enough for you in that case?

I find it interesting because until about three years ago, C++ was always on the other side of this argument. We fight about static type systems. You could shout at the compiler that you know that your code is correct even though the type system doesn't pass. Why does the committee think it knows better than me! Everything is just bits after all!

Now we are on the other side. C++ people saying "bro I totally promise I'll initialize this data member before it is used, stop making me initialize it in my constructor"

munificent3• 2 years ago

This is such a silly send-up. They don't know what's good for me. They tell me what their language is good for. I decide if what the language is good for is good for me.

vundercind2• 2 years ago

How could they know that?

They might know how to design a language such that it tends to produce exceptionally readable codebases, good performance, and improved safety, though. Maybe not all three at once, but some mix of those that’s better than existing languages, perhaps.

stouset2• 2 years ago

The same reason we all use structured programming instead of goto.

scrubs• 2 years ago

If Austin Powers was a programmer:

On a leash? What? ... [if only I could work in a] consequence-free environment, I'll be sound as a pound!

spease• 2 years ago

In other words, the “feature” those languages have is reducing the cognitive complexity and more tightly bounding the risk.

Newer languages are adding friction or dropping altogether things that you rarely or never want to do, to more tightly constrain the space of possible actions to the set of desired actions.

Log_out_• 2 years ago

so experienced cc devs dont need it and the dream is mostly about creating experienced devs who write fast software damage limited by the guardrails of the environment? so its basically the c#\java world of cheap oo software crawling over moores plateau hopping for one more silver bullet that will fix lowcost development,trying to solve the expensive quality dev shortage once more by cheapening out.

Shawnj22• 2 years ago

At least in aerospace we use C++ because we need a bare metal language and C++ is the most full featured/widely used one. Rust is great but toolchain support just isn’t there yet and ADA/Spark aren’t widely used anymore for new development.

wslh2• 2 years ago

Great article more about different approaches to building software that languages themselves.

My two cents: it is improbable that C++ will be ever replaced because it is a mastodon as a programming language: super complex, where complex includes complexity as difficulties and also its vastness. This doesn't mean that it will increase its usage since it is common nowadays to use specific programming languages (e.g. Python) for specific purposes and rely on C++ and others for very specific areas. Personally, I really liked SWIG [1] as a wrapper and interface generator. Don't know how much it is used today.

Other experience but similar conclusion than the article.

logtempo2• 2 years ago

Is a language can be too big to fall? That's an interesting question tbh.

wslh2• 2 years ago

Good question. My personal take is that C++ makes many developers happy, comfortable, and you can develop in C++ using different approaches, that is enough. There is no programming language for all and I think this is why we have a lot of them now and even DSLs.

I consider myself far from what is considered professional C++ knowledge, but for cryptography I always relied on Crypto++ [1] and that made me decide for the use of C++, at least partially. I think we can apply the same thinking for JavaScript or TypeScript, personally I don't like too much those programming languages but if I need to write a RESTful backend I go that route because they have good modules for that or sometimes I decide for Python.

[1] https://www.cryptopp.com/

Shawnj22• 2 years ago

C++ is kind of a “language of last resort” type thing where you use it if there isn’t another good option for what you want to do. Eg. Most desktop development was done in C++, but now C# and newer languages have killed off C++ for most desktop apps. So C++ is still widely used in embedded/performance critical use cases, but Rust will replace a lot of it over the long term.

deterministic2• 2 years ago

New C++ projects are started every day. And billions of lines of C/C++ runs the world. So C/C++ will be around and used heavily for a very long time. Probably way beyond the retirement age of anybody reading this.

pornel• 2 years ago

Looks like the author is very focused on maximally optimizing some very compute-heavy signal-processing code, and doesn’t care much what is used outside of the compute kernel.

So it may be very true that for their work it’s all the same whether they use C++, or Python with numeric libraries, or some niche DSL, or a macroassembler.

But use of C++ is much broader than pure compute, so this perspective does not generalize to C++ or Rust as a whole.

pjmlp3• 2 years ago

But that is the thing, actually.

Little by little, domains where either C or C++ would be the option to go during the 1990's, with exception of areas where VB and Object Pascal (Mac/PC variants) were enjoying adoption, have been slowly taken away from them.

Bjarne created C with Classes for his distributed systems research at Bell Labs, nowadays the majority of CNCF project landscape is written into something else.

C++ GUI frameworks were all over the place during the 1990's, nowadays one has to go to third parties, as platform vendors rather focus on managed languages. Even C++/WinRT going into maintenaince is an acknowledgemnt from Microsoft that outside Redmond XAML / C++ was a failure in regards to adoption.

Long term we might be left with LLVM, GCC, Unreal, Skia, CUDA, and a couple of other key projects that keep C++ relevant and that is about it.

lamontcg• 2 years ago

Yeah if you define the utility of C++ so narrowly to these very highly micro-optimized use cases then Rust can easily capture 100x the mind share of C++ because programmers generally just don't need to care that much. And really seeing what advanced Rust programmers can do when armed with godbolt I'm not convinced even those use cases demand using C++.

bun_terminator2• 2 years ago

Do you know that in MSVC uint16_t(50000) + uin16_t(50000) == -1794967296?

Not only is that insane code and both my compiler and static analysis go for my throat, it's also not true. I think the argument is supposed to be about unsigned integer overflow, but the numbers don't add up. The big negative number wraps to 63744. And the sum (100K) wraps to 34464.

dzaima• 2 years ago

It seems the intent was for "*" to be used instead of "+". At which point it's actually undefined behavior even though the operands are unsigned!

bun_terminator2• 2 years ago

that makes more sense!

lookitsnicholas• 2 years ago

may be slightly off-topic, but that website favicon is suspiciously reminiscent of the logo that Ableton currently use hahah

omoikane• 2 years ago

Do you know that in MSVC uint16_t(50000) + uin16_t(50000) == -1794967296?

There are two typos in this statement, one is "uin16_t" should have been "uint16_t", the other is that the "+" should have been "*". Searching for 1794967296 yields this answer:

https://stackoverflow.com/questions/18161443/type-casting-wh...

tomcam• 2 years ago

I made a simple Lisp-style interpreter to help game designers automate resource loading, and went on a vacation. When I was back, they were writing the whole game scenes in this interpreter so we had to support it for a while.

I very much want to hear that story

mgaunard4• 2 years ago

Of course I know that uint16_t+uint16_t gives an int. If you're gonna be programming in C or C++, you need to know these things.

And yes, I do agree the fact that I know so much minutiae about those languages is part of the reason why I'm reluctant to go for something else I have a more shallow knowledge of. But that level of attention to detail is also what allows me to deliver high-quality code that does exactly what I intend it to do.

lifthrasiir• 2 years ago

If you're gonna be programming in C or C++, you need to know these things.

You have to, not you need to. Of course I know plenty of them (so much that I have won IOCCC a decade ago), but most of them are just pure hindrances and do not contribute to anything positive.

_xivi• 2 years ago

Related discussion:

The C++ Killers (Not You, Rust) - Feb 2023 (59 comments) : https://news.ycombinator.com/item?id=34792932

It seems author has published the article last year but moved it to his blog now

npongratz• 2 years ago

Just as Latin never actually died, just like COBOL, Algol 68, and Ada, – C++ is doomed to eternal half-existence between life and death.

I'm almost afraid to ask, but I'd love to know: are there any Algol 68 projects in active use? Anyone have war stories of maintaining them (bug fixes, new features, improvements to interface with more modern systems) in the last couple decades?

zabzonk13• 2 years ago

certainly not active, but back in the 1980s i got dumped on a program that used algol, bcpl, fortran and cobol to drive a phototypesetter to do ... something. this took advantage of the fact that the dec10 allowed you to mix & match languages, much like the vax. i suppose i was lucky the idiot that originally wrote it didn't throw lisp into the pot.

anyway, as i was hired as a microcomputer specialist, and as two dec10 systems programmers had ducked it, i simply said "no can do" - a valuable lesson.

this is what i like about HN - recalling things i had completely forgotten!

jamesfinlayson2• 2 years ago

A company I used to work had an Algol system running until 2005. A rewrite had begun in the 1990s and went live in 2001 and the two systems were run side by side until to make sure the new system was correct.

JohnL4• 2 years ago

Possibly. It was basically the native language of Unisys A-series mainframes and I guess those are still around in some form or other.

jamesfinlayson2• 2 years ago

Ah makes sense - I believe the Algol system I mentioned in another comment was running on a Unisys mainframe.

mgaunard4• 2 years ago

The sine polynomial is bad because it's not written in a way that removes redundant multiplications.

Those redundant multiplications cannot be removed without fast math because floating-point operations are not associative.

There are well-known optimal ways to evaluate a polynomial, namely Horner's and Estrin's schemes.

marmaduke• 2 years ago

Numba is great but missing explicit simd, stack allocated arrays, and user defined types, to name a few things. I tried to keep my colleagues in Jax these days.

aoanla2• 2 years ago

It's also a weird thing to bring up (Numba being great because it can jit-compile python to any arch, including GPUs) when the author discounted Julia... which has exactly the same property.

shadowgovt2• 2 years ago

The difference is uptake. Julia's good and it's out there, but relative to the users of Python... How many people care how portable the Julia code they aren't writing is? The existence of a tool to jit-compile Python is more useful to a lot more engineers than the existence of another language that is nicely jit-compileable.

xiaodai• 2 years ago

Nicely written. I learned a lot

UncleOxidant• 2 years ago

TIL about Spiral[1] and ForwardCom[2] which both look intersting.

[1] https://www.spiral.net/

[2] https://www.forwardcom.info/

malkia• 2 years ago

Talking about other languages...

My fav Go feature is the memory ballast - it's real, lots of go programs have command-line to set it up, and no one cares about it anymore

https://blog.twitch.tv/en/2019/04/10/go-memory-ballast-how-i...

diimdeep• 2 years ago

user: todsacerdoti
created: January 17, 2020
number of submissions 10798

Do you auto post from some aggregation script, mind disclosing why you do this, what sources do you use?

https://www.alexmolas.com/2024/02/12/hn-index.html

logtempo2• 2 years ago

Remind me of this: https://www.nature.com/articles/s41586-022-05172-4

Improving the efficiency of algorithms for fundamental computations can have a widespread impact, as it can affect the overall speed of a large amount of computations. Matrix multiplication is one such primitive task, occurring in many systems—from neural networks to scientific computing routines. [...] We further showcase the flexibility of AlphaTensor through different use-cases: algorithms with state-of-the-art complexity for structured matrix multiplication and improved practical efficiency by optimizing matrix multiplication for runtime on specific hardware. Our results highlight AlphaTensor’s ability to accelerate the process of algorithmic discovery on a range of problems, and to optimize for different criteria.

And I'll emphasis this sentence, as it seems to be the main goal/critics of the author in this post:

improved practical efficiency by optimizing matrix multiplication for runtime on specific hardware.

The C++ Killers (Not You, Rust)

Related Stories