HN Simulatornew | past | comments | lists | submit | teiferer's commentslogin

There will only be very few generations of people who can see photos of them running around at the beach as small kids. That window closes faster than it opened just a few decades earlier.

Seems like they want to play in the big boys club (Google, Facebook, ... ) where this kind of treatment is standard.

The difference of course is that Facebook are experts at doing nothing at all about CSAM that you report to them.

> In a truly sane world, JavaScript would never have happened, either!

Out of curiosity, what do you envision would have taken its place in frontend, in that sane world? (Honest question, no bad faith agenda.)


No language that perfectly fills that niche exists, because none was ever needed. JavaScript eventually became Good Enough. Python is OK, but it’s an old language at this point and it suffers a lot of technical debt.

JavaScript’s biggest weakness IMO is its absolutely abysmal standard library, particularly in terms of data structures. (At least we have Map and Set now, but still no way to define a hash/equality function for a type…) The situation is so bad that essentially any other modern programming language would be an improvement.


So your main criticism is not the language itself but rather its ecosystem?

I for one wish python had taken the spot JavaScript holds.

> But those subject matter experts typically gain their expertise on the job,

For some things, mainly practical applied skills, that is the case, but for a whole class of others it is definitely not. Theoretical foundations are one such area. Whatever you do not learn in college you will never pick up in the job. I have may colleagues who were weak on complexity theory or database theory or things like security fundamentals or number theory or even probability theory and they have never managed to bridge that knowledge gap compared to their colleagues who were strong in those things right out of the gate. Make sure to deep dive at uni, that is likely the only chance you get. (No, watching a bunch of youtube clips does not cut it.)


> For example, learning to play a piano is training the spine, not the brain. Because the feedback loop with the spine is shorter.

It may train the spine too but good luck trying to play the piano without a brain. More concretely, your eyes read the notes you like to play, your ears provide the feedback loop whether you are playing the right thing (and dynamics and interplay with other musicians in an ensemble), and you need things like planning ahead, sense of form, etc. Twiching fingers from some spine impulse is just part of playing the piano. (Besides, the latency between brain and finger muscels is insubstantial w.r.t. the time scales you need for general music playing, beyond certain nuances.)


> It may train the spine too but good luck trying to play the piano without a brain.

I think you missed the point.

The brain is the general, the spine is the sergeant.


Let's recall what I responded to:

> For example, learning to play a piano is training the spine, not the brain.

What does this have to do with a general and a sergeant? It's a quite obviously false statement. Both spine and brain are trained, which I tried to illustrate.

In fact, separating spine and brain functionally in this context is not useful. Both are part of the neurological apparatus that is involved in the adaptations caused by training. It's that apparatus in its entirety that gets trained, involving most of its components along the way. Claiming that only a piece of it gets trained does not match reality, sergeant or not.


> Some are incredibly stupid.

That's from an anthropomorphized angle though? In their evolutionary niche, their level of expressed intelligence seems to be spot on, otherwise they'd have evolved or been outcompeted long ago.

In fact, some of those species that you might consider "incredibly stupid" may have existed long before humans and might easily outlive us if we follow some not-very-unlikely paths that we have opened up with technology and (lack of) social maturity. Who is "incredibly stupid" then?


> That's from an anthropomorphized angle though?

There's some bias from how you measure intelligence but bias only goes so far.

> In their evolutionary niche, their level of expressed intelligence seems to be spot on, otherwise they'd have evolved or been outcompeted long ago.

Thinking is expensive. Being "spot on" for a niche doesn't imply much about stupid or not-stupid.

> In fact, some of those species that you might consider "incredibly stupid" may have existed long before humans and might easily outlive us if we follow some not-very-unlikely paths that we have opened up with technology and (lack of) social maturity. Who is "incredibly stupid" then?

The ones that can't figure out problems/puzzles are the ones that are stupid, using the definition everyone else in the conversation has been using.


You can be stupid and still well adapted to your niche. Most of existence doesn't require much in the way of intelligence.

A pigeon might be perfectly optimised for doing pigeon things, but it’s still almost as dumb as a rock, and I don’t even mean a particularly smart rock.

Though lots of humans' "slow decisions" are really just the conscious mind working hard to justify something that the fast path had already decided long ago. We are exceptional in lying to ourselves.

"Intelligence" is just post-hoc rationalisation of our instincts.

Some just have better instincts than others.


Agree with everything you wrote, but if you go look for bloat on your storage device, the last thing that will be of any significance is that overhead.

The biggest the things on my disk are VMs , docker images, and then I don't care to bother.

> and don’t show the source

At this point, LLMs can just parse the machine code in your binary.

By doing closed source you are making it harder for the good guys (humans trying to learn sth or contribute) but not for the bad guys (LLMs getting trained or otherwise reading the code).


That’s fair but it takes deliberate reverse engineering to extract code from a closed binary, and you might land at something inferred, but generative AI is not being trained on reverse engineered assembly unless it is task-specific model being trained for that.

But you’re right, the fact is we simply live in a different world today and it’s tough to say what is the path forward.

But it’s harder to justify giving to the public when companies are making money on our work. It’s not a good situation for creators across the board unless motivations are purely altruistic.


I'm not really sure that's how open source actually works. There may be cases where some lone hacker in a basement writes some code and then open sources it for the betterment of the world, but that could be rare cases. I'm mostly seeing bigger players getting business advantages out of this, real or at least envisioned. Cred with users, broader adoption, this kind of thing. And if I at my job find a bug in an open source package that annoys me then after fixing it I of course upstream it since I don't want to have the constant headache of maintaining an in-house diff. LLMs make that easier but it is even easier to send it upstream and forget about it.

Well most open source projects typically tout something beyond financial incentives. Sometimes it works for a business model too.

But we’re talking about the case where any AI can steal the code or be trained on it and derive something from it, changing the license for instance, even if the codes license prohibits commercial use.

I’m not sure anyone who creates open source software is okay with that, especially when using AGPL etc.

There are many cases of sole maintainers who don’t get compensation or even credit for work used by thousands of companies.


You may have noticed the wave of "rewritten in rust" software in recent years, whose only (?) selling point was that this makes the software somehow automatically safe and if not bug free then at least significantly lower on bugs.

This finding is just yet another nail in the coffin of that myth.


I have never understood this argument. Rust, by default, is safer. This is trivially true. But it also is not perfect.

This entire argument against Rust hinges on it somehow invalidating all of the improvements it does have, all the safety it does guarantee, just because it also has a few bugs. It's neither a myth that Rust is safer, nor is it a nail in the coffin for it.

Otherwise you must make the argument that just because unsafe exists, and is used, it is automatically as bad as let's say C - a language that has proven time and time again how trivial it is to make mistakes with. Something that just doesn't happen in Rust.


In addition to that, many of reported soundness issues rely on adversarial implementations for stdlib' traits by user's types, like Borrow::borrow or as_ref returning different value between back to back calls. You would do that if you try to break compiler, but not when writing regular programs.

Well, either it is safe or it is not. Once there is a crack, creative attackers tend to find ways to exploit cracks and pry them wide open.

That is not to say it is not an improvement. But downplaying issues does not help improving the situation. Fixing them does.


I don't really understand the threat model here, how would one "exploit" these issues? It's not like we use Rust as a sandbox (like e.g. JavaScript). If an "attacker" wants to crash the process, they can just write std::process::abort(), or if they want to break memory safety, they can just use an unsafe block.

Sophisticated exploits often are a creative chain of prying open cracks that may just have looked like innocent bugs until they were used in the right moment ans right context that made them a very useful piece in a puzzle. The naive view of a buffer overflow was also just "yeah well great they can crash the program but they could get that cheaper". Until somebody had the idea of overwriting return addresses or putting executable code there. It may be hard to say how a bug can be exploited. As long as something says "safe" but suddenly an asterisk pops up, that's the first step down worry lane.

I don't doubt that it is indeed safer. But some people do act like all bugs are gone.

> This entire argument against Rust

No, it is not an argument against Rust, it is an argument against a particular sales pitch. The "nail in the coffin" is not for Rust but for that sales pitch.

I personally like Rust and think it is a great improvement over C for many use cases and it provides a refreshing angle as an alternative to GC approaches. Just some evangelists are going too far.

Please let's use some nuance here.


The annoyance comes from the fact that your kind of _reasonable_ discourse on safety is always thrown when there is a bug, but never when there is a claim that rust is 100% by construction. I.e. It's always a defensive argument, but I never see someone step up to mention it on overly optimistic claims.

I can't be defending the statements of whoever says this, but I do think that the reasonable way to understand it is that the fundamental model that the Rust compiler and standard library attempt to implement is safe and correct by construction, rather than as a statement about the concrete implementation.

Among software developers, we shouldn't need to provide a "assuming there are no bugs" caveat with every statement about how something works, because we know that bugs are essentially unavoidable at scale. We can say that Rust makes it much easier to avoid bugs, but nobody serious has ever claimed that they are 100% eliminated.

It's not like C or C++ compilers are bug free either, despite implementing much weaker models.


> the fundamental model that the Rust compiler and standard library attempt to implement is safe and correct by construction

This comes up a lot as a defensive argument too, but it's also pretty frustrating, because Rust's "fundamental model" is not a thing that really exists. There are project proposals to create one (such as https://goals.rust-lang.org/2026/roadmap-project-zero.html#), but at the moment it's just a vague set of vibes people gesture towards to dismiss all the problems with Rust-as-actually-implemented.


Calling it "vibes" is just so unserious.

If you would like the Rust language to have a formal specification, I would suggest you look at ways to help that happen. There is already the Ferrocene[1] project.

The safety model of Rust is extremely well described in detail. It's not particularly hard to understand, either. Are you worried that there is some kind of fundamental flaw in the design, we're just waiting to discover it, and it will all come crumbling down? My suggestion would be to start by understanding Rust's type system and why it works the way it does, and you will very quickly build an intuition ("vibes") that it obviously works.

[1]: https://ferrocene.dev/


If your intuitive understanding of Rust is that its type system "obviously works", then you have developed an incorrect understanding! There are many documented cases where it does not work, and there is an active project to change its design so it works in more cases.

I don't think we should accept this kind of vibes-based reasoning from C programmers who are confident their programs don't have any memory bugs, and we shouldn't accept it from people trying to sell us programming languages either.

I think it's reasonable to say that Rust successfully prevents a lot of memory issues, and that it's it's a good choice for lots of projects. But it frustrates me when people try to dishonestly argue that it's perfect and then retreat to arguing that the implementation is flawed but the design is perfect, because neither statement is true but they take a lot of oxygen away from efforts to improve the situation.


> There are many documented cases where it does not work, and there is an active project to change its design so it works in more cases.

Are you referring to the implementation or the model? Because there are several bugs in the implementation, but they are very clearly bugs.

If you're aware of any actual holes in the type system as it is designed, I think the Rust lang team would be very interested in hearing about your paper!


I am referring to the one that exists in material reality, and not just the collective imagination of the people making this dishonest argument.

Wait, so you believe that unless the program's behavior is described by an ISO standard document, bugs cannot exist?

"It's a feature, not a bug!" taken to the next level. I guess I admire your dedication to obstructing reasonable discourse.


The problem isn't that Rust doesn't have bugs in it. The problem is when people try to say that Rust is an "implementation" of some thing that does not have bugs. This is only true because it's not possible for there to be bugs in a standard which does not exist. It creates the impression that the Rust team did design work that they have not actually done yet.

"But my mental model of Rust is not detailed enough to notice the bugs!" That's great, but that's also true of every bug, including the ones that are caused by major design defects, so it's not really saying much.


I mean it would be nice to make one of those, but I also don't really see the point of doing so besides shutting up the guys who like to talk about how Rust doesn't have a spec, most of whom do not even seem involved in the language really? Nobody really has an issue with the current situation, they are all clearly bugs and they more or less get triaged appropriately.

Funny. I would think a GCed language was safer - maybe Haskell being the safest of all (outside even more niche languages) for its ability to encode so much in the type system.

Yet, for some curious reason, a substantial group of snake oil salesmen insist that only this one particularly cut puzzle piece (rust) fits the bill.


Who, exactly?

It has been known for decades that GC was one way to achieve memory safety. That was one of the main selling point of Java back in the 90s - no more segfaults.

Rust was an absolute breakthrough, because it provides a second way to gain memory safety, this time without the significant drawbacks of a garbage collector, bringing memory safety to systems programming. That's materially different.

The only other previous attempt at this was Ada, which for a variety of reasons never quite fit the bill despite its obvious strengths.


> Who, exactly?

I'm on your side of this, but there are Rust zealots out there and they're incredibly annoying.

(Edit to add:)

As a longtime Java guy (after a decade or so as a C++ guy) what drew me to Rust wasn't actually memory safety; that was table-stakes for me and Go might have lured me in if that was all I wanted. The low-cost (cognitive complexity is a cost) of memory safety was a factor, but it was the expressive type system that sealed the deal.


Which ironically has been available since Standard ML in several descendents, including Scala on the JVM, yet Rust keeps getting the glory.

Sure, but it's nice to be able to trivially distribute a binary so JVM based languages have a hindrance there. I'll set performance concerns aside as for my purposes they're usually irrelevant.

Otherwise Scala was nice in some respects, less nice in others (purely a matter of personal taste).


There have been AOT compilers since Excelsior JET back in the mid-2000's, among others in the enterprise and embedded commercial space, nowadays GraalVM and OpenJ9 are available as free beer, so paying for AOT is no longer an issue.

Scala also has a LLVM backend.


Right, but there's too much reflection in JVM language libraries for this to ever seem a very appealing option (to me, YMMV).

I'm not saying the choice is strictly rational, just that when I came across it Rust ticked a lot of my boxes and I've since then found it a pleasant language with no more than the usual level of frustrations.

I like Java too though, so draw your own conclusions.


> I'm on your side of this, but there are Rust zealots out there and they're incredibly annoying.

I mean, I keep hearing about them, and they just literally never show up anywhere I am, and I'm pretty active in the Rust community.


I dug out this example:

https://forum.qt.io/topic/142885/rewriting-qt-in-rust/10

They might not be that common but they're definitely out there, and memorable, and irritating. You can see why it colours people's impression of the community.


I skimmed the topic. This is a forum post seemingly asking an honest if ill-informed question, and it seemed to foster an interesting and informative debate about why Qt isn't a good candidate for being rewritten in Rust.

I didn't notice any toxicity from either side at all, though admittedly I did just skim.


Ok, maybe "zealot" is the wrong word, but the guy (says himself he) doesn't really know Qt or C++ but is very sure that they should rewrite in Rust.

I think that's the kind of interaction people find irritating even if you don't see it.


Cyclone was the breakthrough, not Rust.

Also you gotta write the garbage collector itself in some language that isn't itself garbage collected - usually C or C++, before Rust existed.

Anyway, it's basically slander to say that people advocating Rust are snake oil salesman. Rust is a genuine improvement to systems languages over the existing options (primarily C/C++) in multiple respects, not just memory safety; it is not a panacea that solves every problem or eliminates every possible bug, and no one involved with the project ever claimed that it did.


This is a common mistake to voice out, since Lisp was created it is possible to write GC implementation in such languages, history is full of examples.

For the record here is the Oberon GC implementation, in Oberon.

https://people.inf.ethz.ch/wirth/ProjectOberon/Sources/Kerne...

If you want a more trendy example, check D or Go.


" no one involved with the project ever claimed that it did" - this may be true, MAY. But the Rust community is a large tent and, unlike Zig, Odin, Go, Java or whatever unusually motivated to roll in and suggest that a rewrite in their favorite language is necessary.

The amount of times I've seen, even on HN, not rewriting the world's C/C++/Zig/Odin software in Rust is a moral failing is.. well.. I've never seen any other language community argue that way - and this, very naturally, breeds animosity.

As for systems programming, whether Rust fits the bill is a much deeper and nuanced discussion than most drive-by Rust commentators seem to have patience for. I'd point out that in spite of C++ (also a language prioritising RAII) most serious systems software is written in C. Ignoring this fact and insisting that a new, better RAII language is the panacea of systems programming seems to me just a little unserious.


Most serious systems software is quite bad, full of security vulnerabilities, and being written in C has a lot to do with that. C's design makes it very easy to write code with subtle bugs, often security issues, and indeed most systems software written in C is full of security vulnerabilities and has been for decades.

I myself think that we should rewrite most of the world's C and C++ in something else (I specifically include the Linux kernel in this, among many, many other pieces of software). Rust is obviously a strong contender here, but this is not a specifically pro-Rust viewpoint, but an anti-C/C++ one. As I said, I don't think that Rust is a panacea or that it's reasonable to conceive of Rust as a panacea. I even think it is important to research new systems languages that are not Rust and that go even further in the direction of statically-guaranteeing program correctness properties than Rust does - I explicitly do not want to treat Rust as the only good or worthwhile language to write systems software in. This doesn't mean that the C/C++-based status quo is good.


A GCed language wouldn't be safe from the kinds of bugs exhibited in the OP, all it takes is a bug in the runtime.

Yes, that's a myth.

I, like many others, still think that a language that requires a bug in the compiler for a certain category of error to be exhibited is preferable to one that has no such guarantees. I like C but it's not crazy to consider rewriting a tool in Rust for memory safety reasons.


> automatically safe

> bug free

In most discussions involving Rust I hear those “counter” criticisms, but is it a common claim by Rust proponents that Rust makes software bug free, etc.? I feel like I don’t regularly encounter the original claim that others regularly argue against.


Because?

Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: