ZILtoid1991

Something something history is a flat circle

https://lemmy.world/post/33274870

Jul 21, 2025 at 2:29pmWeb
Show threadm_‮fJul 21, 2025

Relevant comment

I don’t use Rust much, but I agree with the thrust of the article. However, I do think that the borrowchecker is the only reason Rust actually caught on. In my opinion, it’s really hard for a new language to succeed unless you can point to something and say “You literally can’t do this in your language”

Without something like that, I think it just would have been impossible for Rust to gain enough momentum, and also attract the sort of people that made its culture what it is.

Otherwise, IMO Rust would have ended up just like D, a language that few people have ever used, but most people who have heard of it will say “apparently it’s a better safer C++, but I’m not going to switch because I can technically do all that stuff in C++”

I don't use Rust much, but I agree with the thrust of the article. However, I do... | Hacker News

Show threadsocJul 21, 2025

“apparently it’s a better safer C++, but I’m not going to switch because I can technically do all that stuff in C++”

The main difference between C++ and D was that (for most of the time in the past) D required garbage collector.

So, D was a language with similar Algol-style syntax targeting a completely different niche from C++.

Trying to correct your quote, it should read something like “I’m not going to switch because I can’t technically do all that stuff in D that I’m doing in C++” for it to make any sense.

Show threadadbJul 21, 2025

“Before rust you could either have a fast language (C/C++) or a memory safe language (any other language. That is, languages with garbage collector).”

Ada managed to do safe and fast over forty years ago.

Show threadbitcrafterJul 21, 2025
Does Ada have a capability as powerful as the borrow checker?
Show threadBatmanAoDJul 21, 2025
Strictly speaking, no. The borrow checker was a true innovation.
Show threadadbJul 22, 2025

I’ve never used Rust but from my very cursory knowledge of what the borrow checker entails, it wouldn’t add so much to Ada.

Use of pointers is already strongly discouraged by the simple fact that the language is designed to rarely truly need them. Besides, the compiler itself chooses automatically whether to pass data by value or by reference depending on the required results and what is most efficient. You can also specify parameters passed to a function as read-only. Finally, another thing that Ada does to prevent yourself shooting in your foot is to enforce strong encapsulation of functions and data.

Overall, one way to put it in simple terms is that Ada requires the programmer to give enough information to the compiler so as to ensure that it actually outputs what you want it to, which as far as I understand, is sort of what the borrow checker is there for. The downside to the Ada approach is that it is very verbose, but with the kind of code editing capabilities we have nowadays it’s certainly not as much a hassle as it was when Ada came out.

Anyways, I suspect that both languages are different enough in overall paradigm that trying to solve problems in Ada the way you would in Rust would probably be quite frustrating and give rather poor result.

Show threadbitcrafterJul 22, 2025

The borrow checker is a lot deeper than merely making pointer use a bit safer; it provides a model for data ownership based on affine types.

Also, to the extent that “Ada requires the programmer to give enough information to the compiler so as to ensure that it actually outputs what you want it to,” if I understand you correctly, that is basically true of every language with a static type system. At the extreme end, we have dependently typed languages which essentially let you express arbitrary mathematical propositions in your types and, if the program compiles, then you know that they will always be satisfied without having to do any checks at runtime.

Show threadBatmanAoDJul 21, 2025
Before Rust, the main argument I heard from C++ enthusiasts against Ada was that it was a nice idea but too “design-by-committee”. Which, yeah, is an ironic thing for C++ fans to say, but I guess that was enough 🤷
Show threadcalcopiritusJul 21, 2025

I kinda disagree. The reason rust caught on is because it is much safer than C++ while having the same or even better performance. And in some contexts, being garbage collected means bad performance.

Before rust you could either have a fast language (C/C++) or a memory safe language (any other language. That is, languages with garbage collector). But if you required memory safety and peak performance, there wasn’t any option.

Yes, the reason that rust is both memory safe and fast is because it has a borrow checker. But the borrow checker is the means, not the end.

Show threadAnyOldName3Jul 21, 2025
Garbage collection doesn’t guarantee memory safety and it’s perfectly possible to create a memory-safe language without garbage collection. There are plenty of garbage collectors for C++ (and until C++23, support for garbage collection was part of the standard, although no one implemented it), and languages like C# let you interact with garbage-collected objects in unsafe blocks.
Show threadDecqJul 21, 2025
Exactly, if garbage collection meant memory safety then why do we get null pointer exceptions about every 5 minutes in Java. Garbage collection is about memory leaks, not safety. Imho the borrow checker is a better solution than garbage collection and faster to boot.
Show threadNat (she/they)Jul 21, 2025
A null pointer exception is technically memory safe, you can get equivalent behavior with .unwrap() on an Option in Rust.
Show threadcalcopiritusJul 21, 2025

Null safety and memory safety are different features.

Null safety means that you cannot access a struct’s fields without first checking if the pointer to that struct isn’t null. And this must be a compile-time check.

Memory safety means that you cannot read or write to/from memory that has been free-ed. Without leaks ofc, otherwise it would be very easy.

Show threadcalcopiritusJul 21, 2025

How can you not have memory-safety while also having a garbage collector?

Garbage collection means that all objects live as long as you have a reference to it. Which means that you can only dereference a pointer to invalid memory if you willingly create an invalid pointer, or reinterpret the type of one pointer into another. Going out of bounds of an array counts as the first case.

If a language has garbage collection but no compiler/interpreter supports it, then the language doesn’t have garbage collection.

Show threadAnyOldName3Jul 22, 2025
For a start, having a garbage collector doesn’t mean its use is mandatory, but even in a language where the garbage collector is mandatory, keeping an array alive as long as any references to it exist doesn’t stop you doing things like getting muddled about its length and reading/writing past the end. Mandatory garbage collection only prevents temporal memory bugs like use-after-free, not spatial memory safety bugs like buffer overruns, which need to be prevented by other mechanisms like bounds checks.
Show threadcalcopiritusJul 22, 2025

As I said, I don’t consider going out of bounds of a buffer a memory safety issue. Forcing the programmer to handle an out-of-bounds case every time there is an array access can be incredibly tedious. So much that not even rust forces you to do so. And if that language has iterators, it’s even less of an issue.

I consider out-of-bounds array access to same as casting a pointer to another type. Just because a language lets you do it, it doesn’t mean that it is not memory safe. It is a performance feature, since checking the bounds every time is always possible (and incredibly easy to implement), but also with too big of an impact when you could just check the length once per loop instead of per loop iteration.

Show threadsusJul 22, 2025
buffer overflows are critical for memory safety since they cause silent data corruption (very bad) and remote code execution (very very bad). Compared to those a “clean” unhandled runtime error is far preferable in most cases.
Show threadAnyOldName3Jul 22, 2025
If you’re going to change the definition of words, it’s pretty easy to show that garbage collection on its own is sufficient, but it’s not possible to have a useful conversation if someone’s using their own personal definition of the terms being discussed. The generally accepted definition of memory safety includes deeming out-of-bounds accesses and other spatial memory safety issues unsafe.
Show threadcalcopiritusJul 22, 2025
With your definition this conversation doesn’t make sense though. Since rust’s direct array access doesn’t perform bounds checks when building in release mode. And it doesn’t require using unsafe.
Show threadAnyOldName3Jul 22, 2025
That’s not what Rust’s documentation says. It does a compile-time bounds check if it can prove what the index might be during compilation, and a runtime bounds check if it can’t. In release mode, it tries harder to prove the maximum index is below the minimum length, but it still falls back to a runtime bounds check if it can’t unless you use get_unchecked, which is unsafe.
Show threadEuphomaJul 22, 2025
I’ve gotten segfaults in python
Show threadPhenJul 21, 2025
At one point long ago (just for a short while), I thought Delphi was destined to take that place. It was much higher level while still letting you go as low level as you wanted- it didn’t have garbage collection but it made it pretty easy to keep track of what is or isn’t allocated, on top of having good tools to find leaks on runtime. But it had too many problems too: the Pascal base and the association with drag and drop coders being some of the first ones, followed by a series of bad decisions by whatever company was responsible for it at any given week.
Show threadZILtoid1991Jul 22, 2025
The “better” performance is due to the built-in multi-threading support, and that functional programming makes it relatively safer to pull off. Otherwise single-threaded Rust is very hard to optimize.
Show threadantonJul 24, 2025

Rust has monomorphisation like C++ and every function has the aliasing guarantees of restrict, a keyword rarely seen in C code bases use and C++ doesn’t even support.
This means you can get more optimisations while writing in an intuitive style, where C/C++ requires some changes to the code.

On the other hand rustc has some hiccups with argument passing and rvo. One could argue that that’s just the compiler while the aliasing problems are part of the language in the C/C++ case, but while there is only one rust compiler its performance is the languages performance.

For most use cases they are about equally fast.

Show threadZILtoid1991Jul 21, 2025

D has a lot of other reasons why it haven’t caught on.

  • The language is way too similar to both C and C++. In fact, you can get C and C++ code working in D with minimal changes (most annoying part is int meaning different things in both languages), and nowadays I can pull the conversion off on the regular. It’s like the only changes that were made to the language are making things more consistent, making things work better. etc. Rust is more like a language that is a marriage between C-style languages and OCaml. Rust is also a “functional first” language with the ability of opting out from the functional part, first when I’ve heard about Rust it was through this “fancy and new programming paradigm, that promises to fix everything wrong with programming”, and the D team wanted to be left out from making const the default mutability.
  • The GC sounds scary for most people, who want to develop desktop applications. It’s rapid fast, will be even faster soon, and there’s tricks to either opt-out from it, or to get a @nogc thread going (using that for audio).
  • Marketing issues. Walter Bright, while a genius compiler developer, is not a good marketing person.
  • Formerly D was quite infamous for its toxic users, with Walter going infamous for his “let nazis code” line for a while. Allegedly, most of the toxicity moved over to openD, which made some people question why Adam D. Ruppe forked the language.
  • The whole shenanigans around moving from D1 to D2, also Tango.
Show thread6nk06Jul 21, 2025

moving from D1 to D2

I was learning a few different languages at the time, and it’s a bit fuzzy in my head, but I remember the confusion between the 2 compilers. One was incomplete and/or obsolete, and the other one was in beta or something and you shouldn’t use it anyway. I chose nothing and tried something else because it was annoying to watch. Walter, as the BDFL, should have decided on something but it never arrived, and the hype went away.

All I remember is that some Japanese guy wrote a bullet-hell library and game in D, and that was great. But the community was too confusing for me.

Show threadCanadaPlusJul 21, 2025
Yep, and that’s not a bad thing. Switching has a cost, and using the old standby is probably the way to go if there’s a bunch of new things, none of which are definitely, inarguably better than it.
Show threadmamg22Jul 21, 2025
Has Carbon been used anywhere noticeable? Last time I heard of it was when Google announced it few years ago, haven’t seen anything getting written or ported to it, though I haven’t read much into it so I might have missed many news.
Show threadNotSteve_Jul 21, 2025
I actually completely forgot it was a thing. I haven't heard anything about it either since it was announced
Show threadViatorOmniumJul 21, 2025
It looks like a nice mix of some of the worst design choices of C++ with some of the most dubious choices of Rust.
Show threadI Cast FistJul 22, 2025
Oh, so it’s a contender against Brainfuck
Show threadTony BarkJul 21, 2025
I tried programming in D a little. Wasn’t bad. Just up against industry giants.
Show threadZILtoid1991Jul 21, 2025
That’s the best part, it’s not made for industry specs!
Show threadJankatarchJul 22, 2025
I was looking for a “C with strings” and D seems to be about it.
Show threadVeryFrugalJul 22, 2025
Go?
Show threadlime!Jul 22, 2025
that was the stated goal, at first. to replace C for writing os services.
Show threadVeryFrugalJul 22, 2025
yeah, C, not C++.
Show threadlime!Jul 22, 2025
both?
Show threadVeryFrugalJul 22, 2025
Maybe. But Go is much more closer to C than to Cpp.
Show threadFrezikJul 22, 2025
K&R started with BCPL as their base of inspiration. They then made B, and then C. The followup should be called P.
Show threadZILtoid1991Jul 22, 2025
en.m.wikipedia.org/wiki/P_(programming_language)
P (programming language) - Wikipedia

Show threadsquaresingerJul 24, 2025
Lies!
Show threadI Cast FistJul 22, 2025
Some people really suck at coming up with names for their programming languages. There are so many single letter languages (B, C, D, E, F, J, K, V…) that it really makes one wonder what the fuck is wrong with them
Show threadFrezikJul 22, 2025
These days, search engine optimization tends to force new single letter languages into obscurity. Even Go would have issues there if Google hadn’t been behind it.
Show threadI Cast FistJul 22, 2025
Even in the early 2000s, those single letters would be awful as lone search terms
Show threadZILtoid1991Jul 23, 2025
That’s why you put the “-lang” postfix if you have issues with searching for documentation of functions, etc.
Show threadsquaresingerJul 24, 2025
Can’t find a lot searching for java-lang…
Show threadI Cast FistJul 22, 2025
Zig or V could’ve been shown instead of Carbon (the lone C)