200
Rust is now a government conspiracy (programming.dev)
submitted 2 years ago by to c/rust@programming.dev
73 comments fedilink hide all child comments
 

It's getting more and more unhinged on LinkedIn.

A linkedin post by a Senior Embedded Engineer stating: Using Rust is a political solution to deskill a generation of coders to replace higher-cost labor with lower The push for Rust isn't just a technical decision - it's a calculated economic strategy. By forcing rewrites of stable systems in a new language, companies effectively reset the clock on developer experience and expertise. When a C/C++ codebase with 30 years of institutional knowledge gets rewritten in Rust, senior developers with decades of experience suddenly compete on more equal footing with juniors who just graduated. Your 15 years of C++ optimization knowledge? Now worth less than a 22-year-old's six months of Rust bootcamp training. This isn't about memory safety - it's about labor costs. Companies call it "modernization" while quietly erasing the premium they'd otherwise pay for experience. The technical arguments serve as perfect cover for what's really happening: deliberately manufacturing a scenario where they can replace $250K senior engineers with $80K juniors. The pattern is familiar to anyone who's watched other industries. Create artificial obsolescence of existing skills, then exploit the resulting chaos to reset salary expectations and eliminate the leverage that comes with specialized knowledge. This is why language transitions always seem to coincide with hiring freezes and "restructuring." It's never been about technical superiority - it's about breaking labor's bargaining power.
you are viewing a single comment's thread
view the rest of the comments
[–] 19 points 2 years ago (11 children)

Rust is one of the harder languages for beginners to learn because of its borrow checker and strict ownership model, but it shouldn't take more than a month or two for a competent senior to pick up.

It's going to be deeply unpleasant and seem like a problem if:

  • You're writing dangerously bad C or C++ code already.
  • You've only ever used Python or JavaScript.
  • You try to shoehorn OOP and inheritance into it (Rust idioms are composition and functional programming).
  • You refuse to use/learn pattern matching.
  • You're a pedant about "pretty" syntax.

If someone is at a senior level and any of those apply, they probably shouldn't be at a senior level, though.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 11 child comments
    •
  • [–] 10 points 2 years ago*

    You’re a pedant about “pretty” syntax.

    Oh I'm definitely whinging about it but it doesn't make me stop using Rust. People coming from C or especially C++ don't really have a leg to stand on, though, neither do people coming from ML. It's Haskell people who get hit hardest.

  • permalink
  • fedilink
  • source
  • parent
  • [–] 7 points 2 years ago

    Can confirm, I'm a senior and I didn't have much trouble with Rust. After a couple weeks, I was writing useful code. After a month, I generally stopped cussing at the compiler.

    I'm still finding odd surprises here and there, but it's honestly no big deal. I'm about as productive in Rust as I am in Python, which I use at my day job, though I use them for very different domains.

  • permalink
  • fedilink
  • source
  • parent
  • [–] 5 points 2 years ago (5 children)

    I'm still learning Rust coming from Python and R and honestly point 2 and 3 are not even that bad. Sure I have been bashing my head against some corners, and the lack of OOP was somewhat unexpected, but imho the language really helps you think about what you are doing.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 5 child comments
    •
  • [–] 3 points 2 years ago (4 children)

    the lack of OOP

    Rust absolutely has OOP, that's what Traits are for. It just doesn't have classical inheritance, so you structure your patterns a bit differently.

    That said, I lean more into functional-inspired style anyway, which tends to work pretty well w/ Rust.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 4 child comments
    •
  • [–] 1 point 2 years ago* (3 children)

    traits aren't oop. they're closer to haskell's typeclasses than anything else

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 3 child comments
    •
  • [–] 1 point 2 years ago (2 children)

    At its core, OOP is just commingling data and operations, whereas FP is separating data from operations on data. I'm not an expert at Haskell (I cut my FP teeth on Lisp), but that's essentially what typeclasses look like to me.

    The Rust book has a section on OOP, and the main thing to remember is that Rust solves OOP through composition instead of inheritance. Rust doesn't have inheritance in any meaningful way, but it can solve problems in a similar way as classical OOP.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 2 years ago* (1 child)

    i would strongly disagree with that characterization of both fp and oo. classifying rust as oo weakens it imo, and the fact that you can easily solve all the problems oo solves in rust, as your linked document shows, is not proof rust is oo, but rather that oo is unnecessary to solve those problems

    object orientation is classes done wrong. typeclasses (and traits) are classes done right

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 1 child comment
    •
  • [–] 1 point 2 years ago

    Then how would you define OOP and FP?

    Wikipedia claims it supports OOP:

    Rust does not enforce a programming paradigm, but was influenced by ideas from functional programming, including immutability, higher-order functions, algebraic data types, and pattern matching. It also supports object-oriented programming via structs, enums, traits, and methods.

    I wouldn't say Rust is an OOP language though, because that absolutely gives the wrong impression since that evokes ideas of classical inheritance as in C++ or Java. But I do very much believe it supports object oriented programming as a paradigm, since you can model things with objects at the core.

    That said, I think Rust is best used with less emphasis on OOP, since it's pretty easy to get into trouble modeling things that way when it comes to lifetimes. I use OOP-style in Rust when it makes sense, and the rest is as close to functional as I can get it.

    object orientation is classes done wrong

    I think classical inheritance is object oriented programming done wrong. Go had the start of a good idea with composition and interfaces, and I think Rust's traits + generics improved on it.

  • permalink
  • fedilink
  • source
  • parent