4 ms·

There have also been repeated statements from NSA & CISA that they recommend all development should be done in memory safe languages. It's abundantly clear tha

• estebank 23d ago
  A headwind makes it harder to advance in the direction you're going. I think you might have meant to say "there is a strong tailwind towards memory safety".
  • eterm 23d ago
    You're right, I better do a 360 on my comment ;)
    • foolswisdom 23d ago
      A 180 might be more useful :)
      • andsoitis 23d ago
        oh boy, maybe geometry intuitions and spatial reasoning are what's really needed.
        • tigerlily 23d ago
          Or maybe a nice sabbatical aboard a sailboat expedition.
          • imp0cat 23d ago
            Or maybe not, because that's where confusing 180 and 360 degrees or headwind and tailwing will REALLY bite you.
            • lazyasciiart 23d ago
              Sure, but if you come back, you'll have really learned that stuff!
      • shermantanktop 23d ago
        Do it twice to be sure
      • spacechild1 23d ago
        That was obviously a joke...
      • fuzztester 23d ago
        the cool way is turn 90 or 270 degrees n then do tacking. https://en.wikipedia.org/wiki/Tacking_(sailing) https://en.wikipedia.org/wiki/Tacking_(sailing)
    • rotringlvr 23d ago
      [dead]
  • odo1242 23d ago
    > A headwind makes it harder to advance in the direction you're going nit: except in aviation
    • delta_p_delta_x 23d ago
      Also in aviation, but with caveats; you want to take off and land with a headwind, because the headwind gives a greater airspeed which means greater lift.
      • odo1242 23d ago
        Ah
      • aaronmdjones 23d ago
        This is true for takeoffs but not for landings. You want to land with a headwind because this means that for the same airspeed you have a lower groundspeed, i.e. when you actually touch down you're going slower on the runway than if you touched down at the same airspeed but with a tailwind.
        • peterfirefly 23d ago
          In other words, it's because of the greater lift.
          • aaronmdjones 23d ago
            No. Your calculated landing speed doesn't change depending on the winds, so you'll always be touching down at roughly the same airspeed for the same aircraft type, weight, and flap setting. Touching down with a headwind just means you don't need to use the brakes as hard. It's beneficial on takeoff because headwind already factors into your airspeed before you even start rolling, which gives you more lift for the same groundspeed yes, enabling you to rotate sooner than you otherwise would.
            • 23d ago
• jandrewrogers 23d ago
  The recommendation is qualified for typical apps that do not have extreme performance or scale requirements. They use Java for many, many things. C++ is still indicated for systems that are optimizing for performance and scalability characteristics, since it intrinsically requires a lot of "unsafe" constructs.
  • tialaramex 23d ago
    > C++ is still indicated for systems that are optimizing for performance The only evidence I've seen for this is that people with a vested interest in my believing this keep saying it is true. That's the exact same evidence I have for Trump having triumphed in Iran. Do better if you want me to believe you. > since it intrinsically requires a lot of "unsafe" constructs. This is an excellent reason to choose Rust. The whole point of Rust's technology is to enable you to encapsulate the tricky difficult part of the problem so that people don't blow their foot off working on the mundane parts of the software. And the truth is there are always mundane parts of the software. I'm feeling generous so I'll add more here: Vec<T> illustrates how this works. This is a growable array type, C++ has std::vector<T> for much the same concept. But inside Vec<T> this encapsulation is used heavily so that there's a RawVec<T>, which doesn't care about knowing how many things are in the growable array, only about its capacity, then a RawVecInner which doesn't even care what things we're keeping in the array, it's just an appropriately large container for whatever it is, that RawVec<T> remembers what T is if that becomes important - and then a Cap which doesn't even contain things, it's just in charge of being able to represent the capacity correctly while having the same shape as "just" an integer but not always necessarily working like one. Vec<T> is entirely safe to use, very pleasant, no danger. But internally it's extremely sophisticated, hence the layers of different types encapsulating different pieces of the problem to make a growable array type with excellent performance.
    • applfanboysbgon 23d ago
      > This is an excellent reason to choose Rust. The whole point of Rust's technology is to enable you to encapsulate the tricky difficult part of the problem so that people don't blow their foot off working on the mundane parts of the software. And the truth is there are always mundane parts of the software. The problem is that it actually sucks for dealing with the encapsulated parts. The reason everyone loves Rust is because they can just import a package where somebody else did the hard part for them and not worry their pretty little brains about a thing, getting high performance with minimal concern. That is a valid advantage, and that does make more mundane usage of the language safer. But it does not make the unsafe parts safer. There is every reason for having unsafe-oriented languages with ergonomics that actually make working with unsafe code more reliable too. The annoying thing about Rust is that 90% of its users are religious dogmatists who insist that Rust is the only valid language rather than accepting different languages can have different advantages, and moreover that 90% is basically the 90% who are benefitting from Rust while not being the ones who have to write unsafe code themselves.
• TimurRakhmatull 21d ago
  [flagged]