From: m1@m1.com   
      
   Hello...   
      
      
   More of my philosophy about memory safety and inheritance in programming   
   languages..   
      
   I am a white arab from Morocco, and i think i am smart since i have also   
   invented many scalable algorithms and algorithms..   
      
   "Address sanitization is not a security feature, nor does it provide   
   memory-safety: it's a debugging tool. Programmers already have tools to   
   detect that the code they've written has memory problems, such as   
   use-after-free or memory leaks. Valgrind is probably the best-known   
   example. This gcc feature provides (some of) the same functionality: the   
   only new thing is that it's integrated with the compiler, so it's easier   
   to use.   
      
   You wouldn't have this feature turned on in production: it's for   
   debugging only. You compile your tests with this flag, and automatically   
   they detect memory errors that are triggered by the test. If your tests   
   aren't sufficient to trigger the problem, then you still have the   
   problem, and it'll still cause the same security flaws in production.   
      
   Rust's ownership model prevents these defects by making programs that   
   contain such defects invalid: the compiler will not compile them. You   
   don't have to worry about your tests not triggering the problem, because   
   if the code compiles, there cannot be a problem.   
      
   The two features are for different sets of problems. One feature of   
   address sanitization is to detect memory leaks (allocating memory and   
   neglecting to free it later). Rust makes it harder to write memory leaks   
   than in C or C++, but it's still possible (if you have circular   
   references). Rust's ownership model prevents data races in sequential   
   and multi-threaded situations (see below). Address sanitization doesn't   
   aim to detect either of those cases."   
      
   And using just plain C#, it has better memory protection, since the GC   
   and runtime make it impossible to leak, double-free, or access   
   out-of-bounds. C# has unsafe blocks just like Rust does. Safe Rust is   
   just as safe from memory safety problems as safe C#.   
      
   I think that a programming language has to provide "inheritance",   
   and the new Rust programming language doesn't provide it and i think   
   that it is a deficiency in Rust, here is why:   
      
   As a software developer you have to become more efficient and   
   productive. So you need to make sure the code you write is easily   
   reusable and maintainable. And, among other things, this is what   
   inheritance gives you - the ability to reuse without reinventing the   
   wheel, as well as the ability to easily maintain your base object   
   without having to perform maintenance on all similar objects.   
      
      
   Thank you,   
   Amine Moulay Ramdane.   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)