I’m curious how software can be created and evolve over time. I’m afraid that at some point, we’ll realize there are issues with the software we’re using that can only be remedied by massive changes or a complete rewrite.

Are there any instances of this happening? Where something is designed with a flaw that doesn’t get realized until much later, necessitating scrapping the whole thing and starting from scratch?

  • Khanzarate@lemmy.world
    57·
    8 months ago

    The more the code is used, the faster it ought to be. A function for an OS kernel shouldn’t be written in Python, but a calculator doesn’t need to be written in assembly, that kind of thing.

    I can’t really speak for Rust myself but to explain the comment, the performance gains of a language closer to assembly can be worth the headache of dealing with unsafe and harder to debug languages.

    Linux, for instance, uses some assembly for the parts of it that need to be blazing fast. Confirming assembly code as bug-free, no leaks, all that, is just worth the performance sometimes.

    But yeah I dunno in what cases rust is faster than C/C++.

      • 0x0@programming.dev
        61·
        8 months ago

        C/C++ isn’t

        You’re talking about two languages, one is C, the other is C++. C++ is not a superset of C.

    • flying_sheep
      1·
      8 months ago

      Rust is faster than C. Iterators and mutable noalias can be optimized better. There’s still FORTRAN code in use because it’s noalias and therefore faster

    • Nibodhika@lemmy.world
      1·
      8 months ago

      But yeah I dunno in what cases rust is faster than C/C++.

      First of all C and C++ are very different, C is faster than C++. Rust is not intrinsically faster than C in the same way that C is faster than C++, however there’s a huge difference, safety.

      Imagine the following C function:

      void do_something(Person* person);

      Are you sure that you can pass NULL? Or that it won’t delete your object? Or delete later? Or anything, you need to know what the function does to be sure and/or perform lots of tests, e.g. the proper use of that function might be something like:

      if( person ) {
  person_uses++;
  do_something(person);
}

...

if( --person_uses == 0 )
  free( person )

      That’s a lot more calls than just calling the function, but it’s also a lot more secure.

      In C++ this is somewhat solved by using smart pointers, e.g.

      void do_something(std::unique_ptr<Person> person);
void something_else(std::shared_ptr<Person> person);

      That’s a lot more secure and readable, but also a lot slower. Rust achieves the C++ level of security and readability using only the equivalent of a single C call by performing pre-compile analysis and making the assembly both fast and secure.

      Can the same thing be done on C? Absolutely, you could use macros instead of ifs and counters and have a very fast and safe code but not easy to read at all. The thing is Rust makes it easy to write fast and safe code, C is faster but safe C is slower, and since you always want safe code Rust ends up being faster for most applications.