4 ms·

Rust is the final language. Defect free. Immaculate types. Safe. Ergonomic. Beautiful to read. AI is going to be writing a lot of Rust. The final arguments o

• tekne 8mo ago
  Needs monads (not joking)
• lproven 8mo ago
  > Rust is the final language. I honestly can't tell if this is a humorous attack or not. Poe's law is validated once again.
  • echelon 8mo ago
    It's honest. If we can serialize our ideas to any language for durability, Rust is the way to go. It's not the best tool for the job for a lot of things, but if the LLMs make writing it as fast as anything else - whelp, I can't see any reason not to do it in Rust. If you get any language outputs "for free", Rust is the way to go. I've been using Claude to go ridiculously fast in Rust recently. In the pre-LLM years I wrote a lot of Rust, but it definitely was a slow to author language. Claude helps me produce it as fast as I can think. I spend most of my time reviewing the code and making small fixes and refactors. It's great.
    • sdkfjhdsjk 8mo ago
      [dead]
    • klsdjfdlkfjsd 8mo ago
      I'll just stick with C as my lingua franca, and won't be involving Microsoft in my programming life, thanks.
      • tcfhgj 8mo ago
        are you implying that using Rust involves using MS products?
        • klsdjfdlkfjsd 8mo ago
          [flagged]
          • robjellinghaus 8mo ago
            Not Microsoft.
          • DANmode 8mo ago
            You’re thinking of OpenAI and ChatGPT, which has a (now-rocky) partnership with Microsoft. Claude is an Anthropic offering.
            • klsdjfdlkfjsd 8mo ago
              [flagged]
          • drdeca 8mo ago
            Anthropic? ChatGPT is the one affiliated with Microsoft.
      • deleted 8mo ago
        [deleted]
    • jibal 8mo ago
      > It's honest. It's not, nor is it well informed. People are currently developing languages specifically for use by LLMs. > It's not the best tool for the job for a lot of things Then how could it possibly be the final language? > if the LLMs make writing it as fast as anything else - whelp, I can't see any reason not to do it in Rust This has nothing to do with the claim that it's the final language.
      • dontblokmebro70 8mo ago
        [flagged]
      • jibal 8mo ago
        What did I say that is false?
    • hathawsh 8mo ago
      While Rust is excellent, you must acknowledge that Rust has issues with compilation time. It also has a steep learning curve (especially around lifetimes.) It's much too early to say Rust is the "final" language, especially since AI is driving a huge shift in thinking right now. I used to think that I would never write C code again, but when I decided recently to build something that would run on ESP32 chips, I realized there wasn't any good reason for me to use Rust yet. ESP-IDF is built on C and I can write C code just fine. C compiles quickly, it's a very simple language on the surface, and as long as you minimize the use of dynamic memory allocation and other pitfalls, it's reliable.
      • 0x457 8mo ago
        If you're programming for ESP, then embassy is the way to go in most cases. You don't need to learn much about lifetimes in most of the application code. Steep learning curve people refer it is "thing blow up at compile time vs runtime." It's easy to write JS or C that passes all tests and compiles and then wonderful blows up when you start using it. It just forces you to learn things you need to know at IMO right now. My biggest problem with rust right now is enormous target/ dirs.
        • JoshTriplett 8mo ago
          > My biggest problem with rust right now is enormous target/ dirs. We're working on that and it should get better soonish. We're working on shared caches, as well as pruning of old cached builds of dependencies that are unlikely to be reused in a future build.
          • tvshtr 8mo ago
            thanks beejesus! (aka the devs) I'm tired of forcing shit into workspaces just to slightly mitigate these issues
      • Foobar8568 8mo ago
        I feel compilation time is unbearable in Rust, even on MacBook pro M3 max, don't get me started on space
• tmtvl 8mo ago
  > Beautiful to read. Oh my, there's a new language called Rust? Didn't they know there already is one? The old one is so popular that I can't imagine the nicely readable one to gain any traction whatsoever (even if the old one is an assault on the senses).
• ikety 8mo ago
  Why not go full functional programming at that point? If the main issue with FP has been accessibility, then it should really take off now.
  • zozbot234 8mo ago
    When you do fully value-oriented programming in Rust (i.e. no interior mutability involved) that's essentially functional programming. There's mutable, ephemeral data involved, but it's always confined to a single well-defined context and never escapes from it. You can even have most of your code base be sans-IO, which is the exact same pattern you'd use in Haskell.
    • theLiminator 8mo ago
      I actually like rust more than Haskell, but `You can even have most of your code base be sans-IO, which is the exact same pattern you'd use in Haskell.` glosses over the fact that in Haskell it's enforced at compile time.
      • josephg 8mo ago
        Another argument as to why rust isn't the forever-language. My forever language should include effects! Even rust has need of this. For example, I want a nopanic effect I can put on a function which makes it a compile error for anything that function calls to panic.
        • theLiminator 8mo ago
          Though I think it's the closest language right now, ideally you have something that is close to "zero-overhead" as your forever language. I really like how flix.dev looks, but there's always a little nagging at the back of my head that something like rust will always produce more performant software.
        • echelon 8mo ago
          > Even rust has need of this. For example, I want a nopanic effect I can put on a function which makes it a compile error for anything that function calls to panic. This! This apart from build times is my biggest request for the language. Nopanic, nomalloc, etc.
• wolvesechoes 8mo ago
  [flagged]
• the__alchemist 8mo ago
  I would say it's overall the best existing language, probably due to learning from past mistakes. On the whole it wins via the pro/con sum. But ... Still loads of room for improvement! Far from a perfect lang; just edges out the existing alternatives by a bit.
• johnebgd 8mo ago
  Sometimes I forget programming languages aren't a religion, and then I see someone post stuff like this. Programming languages really do inspire some of us to feel differently.
• vovavili 8mo ago
  I'd say that it's taking much needed steps to achieve perfection but many more steps are there ahead. The next language closer to perfection would definitely have a much gentler introduction curve, among other things.
  • DANmode 8mo ago
    Which coding assistant do you think needs a gentle introduction curve?
• JoshTriplett 8mo ago
  > Rust is the final language. > Defect free. I am an upstream developer on the Rust Project (lang, library, cargo, others), and obviously a big fan of Rust. This kind of advocacy doesn't help us, and in fact makes our jobs harder, because for some people this kind of advocacy is their main experience of people they assume are representative of Rust. Please take it down a notch. I think Rust is the best available language for many kinds of problems. Not yet all, but we're always improving it to try to work for more people. It gets better over time. I'd certainly never call it, or almost any other software, "defect free". And I'd never call it "the final language"; we're building it to last the test of time, and we hope things like the edition system mean that the successor to Rust is a future version of Rust, but things can always change, and we're not the only source of great ideas. If you genuinely care about Rust, please adjust your advocacy of Rust to avoid hurting Rust and generating negative perceptions of Rust.
  • estebank 8mo ago
    As a member of t-compiler, seconded.
  • jacquesm 8mo ago
    Thank you, thank you, thank you.
  • josephg 8mo ago
    I’d also add: as a lover of forward progress, I really hope rust isn’t the last good idea programming language designers have. I love rust. But there are dozens of things I find a bit frustrating. Unfortunately I don’t think I’m clever & motivated enough to write a whole new language to try to improve it. But I really hope someone else is! For a taste: I wish we didn’t need lifetime annotations, somehow. I wish rust had first class support for self borrows, possibly via explicit syntax indicating that a variable is borrowed, and thus pinned. Unpin breaks my brain, and I wish there were ways to do pin projections without getting a PhD first. I wish for async streams. I wish async executors were in std, and didn’t take so long to compile. I could go on and on. I feel like there’s an even simpler & more beautiful language hiding inside rust. I can’t quite see it. But I really hope someone else can bring it into the world some day.
• basch 8mo ago
  Rust may be the darling of the moment, but Erlang is oft slept on. As AI makes human-readable syntax less relevant, the Erlang/Elixir BEAM virtual machine is an ideal compilation target because its "let it crash" isolated process model provides system-level fault tolerance against AI logic errors, arguably more valuable than Rust’s strict memory safety. The native Actor Model simplifies massive concurrency by eliminating shared state and the complex thread management. BEAM's hot code swapping capability also enables a continuous deployment where an AI can dynamically rewrite and inject optimized functions directly into live applications with zero downtime. Imagine a future where an LLM is constantly monitoring server performance, profiling execution times, and dynamically rewriting sub-optimal functions in real-time. With Rust, every optimization requires a recompile and a deployment cycle that interrupts the system. Finally, Erlang's functional immutability makes deterministic AI reasoning easier, while its built-in clustering replaces complex external infrastructure, making it a resilient platform suited for automated iteration.
  • wolfy-j 8mo ago
    I can't comment on production viability today but if you assume that language itself is irrelevant then it becomes clear that runtime and engine level is the way to go. We spend quite a lot of time conceptualizing around safe self mod and to build apps that can change at runtime. We ended up using custom Lua VM, type system to catch mistakes, declarative homogenous infrastructure and actor model (erlang inspired). Actor model provides not just a good isolation but also it's much easier for AI to reason (since most of components are not that large), we already able to use it to write quite complex systems with ease. Another upside - in actor model you don't really need any of this fluff with cron jobs, queues and etc, all the logic naturally maps to indended architecture, making implementation of agents _very_ easy. https://wippy.ai/en/tutorials/micro-agi https://wippy.ai/en/tutorials/micro-agi It takes 4-5 files to create mini sandboxed AI agent at top of actor model with ability to modify own toolkit while having system guardails and no access to core filesystem.
    • basch 8mo ago
      I guess at a high level im thinking about what kind of running systems are the easiest to edit as they execute. Maybe I should have even picked clojure for being homoiconioc and not needing to be parst into an ast. The LLM can traverse, prune, graft and transform s-expressions directly with perfect structural accuracy.
• nineteen999 8mo ago
  Working code talks. Bullshit walks.
• jungojango 8mo ago
  If AI gets sufficiently good what will be the point of rust? I can just whip out some C code, tell the AI to make it safe (or just ask it if the code contains any undefined behavior), done.
• pabs3 8mo ago
  Rust lacks dependent typing, which advanced languages like Idris2 have.