It is not available for me.

Probably true

Isnt that the case?

Actually it would have prevented both world wars

Germany borrowed after move

Oscar pfp

He really takes it to another level

@@GrantDavisAwesome unlike the elevator 💀

idk why, not like it's a story full of ups and downs

To be precise: the software worked flawlessly, but Boeings being cheap and didn’t cared about sensor redundancy. The plane had a design flaw which they tried to circumvent with this „feature“, but in silence so they don’t had to re train all pilots.

@@isomorphic97 So same story as the therac then. The code was originally written for a version of the machine that had extra hardware interlocks, and the company decided to be cheap and produce a stripped version without hardware interlocks... tbh, it feels like many of these claims of programmers being at fault of writing faulty software always end up being cases of the software being written for literally completely different machines from the one that ended in production. I guess we need to up our skills and become future seers or something... But I guess nobody really likes rockstar programmer stories where they actually turn out to be right. Makes the rust folks feel insecure.

Just commented on that. Yes exactly. It was the negligence of Boeing engineering itself or I mean Boeing company. Software was working perfectly as initially intended. But didn't correct it for upgraded hardware. So it's not that the software was wrong somehow.

Facts

Bro U just making it up, airbus Boeing uses C++ , because it's has proven behaviour. The memory safety issues happens when unreliable uneducated programmer do the c++ , they have billions of lines of C++ codes and they do have custom profiling tools .. they know exactly what will happens when a function calls how much buffer it needs , so there is almost 0 chances for failing it . Instead of moving to rust from C or C++ they will make more compiler features for memory safety and profiling tools .. it's just a web developer like you imagine that Rust has some magical power ... It's the compiler behind the hood that has some strict rules ... Those C++ programmers in big companies taking 500k salary are not web developer turned programmer in one day , they are highly educated graduates

win-win (can you start writing software for politicians as well? We do need more of them testing Newton's laws)

Well then I urge you to write everything you can in python 2.7 and you'll be doing the world a favor... Finally delivering on that tech adage "don't be evil".

@@Taddy_Mason tbh we don't just work with speculators -- if you're a rural farm owner who needs to hedge your supply with futures, our retail brokerage makes it easier than ever to get onboarded. most IB's and FCM's nowadays are suuuuuuper low tech, and before you can trade you literally have to send snail mail back and forth with them. With us you do OAuth and you get all your docs through a react app. my favorite part of our business is the icons we have for lean hog and cattle futures

LOL

Боромир бы писал на расте!

Who cares about future implications, you have to live in the present and enjoy the now! - Some javascript developer

Exactly. I saw a guy on another video say it was C++, and the uniformed folks believed it🤷🏾‍♂️

Have to make rust viable somehow

Better story would be Toyota's code quality scandal leading to several fatal crashes

Does Rust have anything close to SPARK for Ada or Compcert for C?

In the company I work, using Rust is not even an option. Most of the embedded software in our airplanes is Ada or C.

​@@user-pe7gf9rv4mFerrocene was mentioned in the video. In company where I work we use gcc with MISRA-based guidelines and extensive testing

@@user-pe7gf9rv4m There's RustBelt, which is able to prove that the safe half of rust is semantically correct, and that can be used as a basis to prove that unsafe code is correct. I don't know of a certified rust compiler, though, nor of a move towards one

@@fernandoyamaguchi we would see what happens with Adacore cooperation.

No, I highly doubt the Therac-25 accidents would be prevented by using Rust. We (I?) don't know the exact internals of the machines, but I assume that you would probably write a value somewhere (similar to MMIO) and the turntable would turn to that value. This is just an instruction in hardware, there is no way the compiler will be able to check if the action has been completed, or if the programmer has checked that all the possible events. This is at least one level lower than the maximum depth the compiler can check.

1. Wanna get more views 2. Didn't research thoroughly 3. Setting up the narrative for their own statement 4. Want to spread misinformation So on and so on. Can be anything I'm not saying this creator wants to share misinformation but he could have at least picked another topic or researched more if he didn't know in the 1st place. I don't know, the internet is already a big ocean why don't people dig deeper for some more information just to confirm it, right!?

Was the issue that "pressing the off button did not turn off the stall assist unit" a software issue, or was that just a issue that the training manual was wrong?

@@JeffBartlett-kj6sq There were a lot of issues, including systemic ones, but the softwere was not one of them

I heard Spirit airlines is experimenting with that

Ryanair is taking the lead

If only Flash be still around.........

//getElementById("plane").align = "left"; //never uncomment, but for some reason the code won't run without this line as-is

Probably a better idea than using C or C++.

That announcement was more like recommending the use of programming languages with memory management systems build in, so it was more like "If you can, use any other language instead of C/C++".

Because this bloody language is case insentitive.

100%

This makes sense. Also, peer review and extensive fuzzing are crucial to ensuring the maximum possible safety

But... Rust IS the answer to all issues

The point isn't that Rust solves all issues, it's that it solves a handful of common problems that the others (C, C++) don't. It's a strict upgrade from a security perspective.

Sure, if you say so 🙂

Yes, but I've seen a lot of videos, posts, etc. saying that if you "rewrite in Rust", all your problems are gonna go away and you can live happily ever after without worrying about any bugs!

when he said that? also rust avoid concurrency fails btw (except dead-locks IIRC)

Pfft you think he has enough time with that given how much he is going down on the Rust devs?

Are you talking about runtime speed performance? If that's the case, it should be just a matter of time for the Rust compiler to improve its optimization techniques. Given the stricter rules, rustc can make more safe assumptions than a C compiler. What will always slow safe Rust down, and for a good reason, are runtime safety checks. Checking bounds upon array indexing, checked unwraps, Rc cloning, checked math operations by default, etc. However, these are minor performance overheads that are usually worth the tiny cost. If maximum performance is needed, the programmer could use some unsafe code to avoid redundant runtime checks if the code design already rules out the possibility of the check failing (e.g. if a specific branch is executed, then we can be sure that this Option is Some). Unsafe operations like Option::unwrap_unchecked(), mem::transmute(), and ptr::read_unaligned() will speed up your code by a tiny amount, but you must be sure of the validity of your code when you use them. Alternatively, you could redesign the code to eliminate the redundancy of runtime checks while still using safe Rust, which should be your first choice in most cases.

It will not compile because "John" is &str and not String. You should do "John".to_string()

@@huihuihuihuihuihui1 Okay thanks for that, but if i wrote it like this -> let first_name: String = String::from("John"). Now is it correct and is there anything thats misleading ?

@@noormohammedshikalgar depends on what your intent with the code was, but I can't see anything being misleading

Okay, well I heard that using type annotation like u8 and String after variable names is misleading, Its not the proper way to write Rust Is that true ?? Can I ask you, are you experienced in Rust ?

@@noormohammedshikalgar most of the times you can avoid specifying the concrete type of a binding (let variable) because the Rust compiler is designed to guess the types (type inference) from context. When the compiler is unsure about the intended type, then you should annotate it or do other things to help with type inference. I code in Rust since 2018

Knowing C (and a whole bunch of systems programming and cybersecurity) helps you understand where the restrictions Rust places on you come from. However, it is not a prerequisite for learning Rust. Also, if you try hard enough you absolutely CAN write unsafe code, although you generally have to specify it explicitly. That's a good thing, since you can tell where the bug occurs, because you know where it doesn't. From Rust to Python, enjoy the pain (and most importantly happiness) of using static types.

@@user-yv1qs7sy9d thank u! Yes thats what I meant. Sometimes the types annoy me, but just recently i faced my first ever integer overflow, and i realised how much python shields us from this. It's a good pain, I enjoy learning rust. I am still stuck with the borrowing, but rust analyzer helps alot. I like how speedy things run now I am considering porting my simple projects into rust haha

@senbonzakura662 thanks! I am guessing an intro to C would be good enough? Especially when it comes to memory management. And I get your point of view, I have a friend who says you even need to learn assembly to write better code 🤣

@@waynelau3256 Have fun porting!

So you missed the first time?

No, just completely unbiased news

The dude who runs this channel just advertises Rust to the detriment of their informational value.

This take is stupid as fuck.

*Bogdan

i don't think you watched the video lol

Oh man. You're completely uneducated about what unsafe in Rust is.

qi shi

There are plenty of examples of Rust being faster than C. And plenty of vice versa. It depends on the context. I would say in the general case they're about the same speed-wise. Rust is just more ergonomic, easier to write, harder to make mistakes

COBOL is your choice

then you'll be surprised to learn rust does work

@@arson5304 Clearly it doesn't. It has a ton of features to prevent working.

@@doyouwantsli9680 like what

The dudes video wasn't that great and that Rust wouldn't have solved this issue, the issue was boeing being cheap fucks and choosing money over lives, and this dude rides rusts meat harder then when my step mom was being bricked down by tyrone. But I still think Rust is the best option to when you need safe and fast code. If you're making a web server or website then use Go, Golang is awesome, but I really doubt many devs actually work on applications where safety and performance are big concerns since most people seems to just use js, java, and C# for everything. Rust has an unsafe keyword so you can call on unsafe code because it lets you have direct access to memory like C. The point is that you're supposed to make safe abstractions over unsafe code. And I honestly don't know if it's even possible to have a systems level lang that cannot do unsafe things (dynamic allocations, dereferernicng pointers, etc). For instance dereferncing a pointer and reading into it at any given location is unsafe because you can read into random places in memory and even too this day leads to many vulnerabilities and bugs in langs like C. So if I had a dynamic array and wanted to implement a get method to get the value at a given index I could write this unsafe get(&self, index: size) -> T { return unsafe { self.ptr.add(index).read() } } But that's unsafe because I can read to literally anywhere in memory, so instead I can create a safe abstraction over it get (&self, index: size) -> Option { if index >= self.len { return None } else { return unsafe {.Some(self.ptr.add(index).read()) } } } Now I'm still using unsafe code because reading into raw pointers at any index is unsafe, but I return a None variant if you try to read into somewhere where you aren't supposed which now makes the function safe. I know you probably just blindly hate on rust every chance you get cause most rust users I see online are obnoxious and meat ride the language every chance they get but personally it's super well designed and I think it honestly the goto for future software that needs to be safe and fast. I think you should give it a try instead of blindly hating on it without really knowing anything about it 👍

unsafe doesn't mean it disregards all rules of the language. It still enforces them. The only extra things it allows you to do are: dereference raw pointers, call other unsafe functions, access or modify a mutable static variable, implement unsafe traits and access fields of unions. The other restrictions are still there! It doesn't disable any other Rust safety checks like borrow checking or strict type checking

How is it a lot of BS? I write Rust code and love doing it. For the last 7 years, Rust has been the #1 most loved programming language with the stack overflow community. Please explain.

Tell me you're a JS dev without telling me you're a JS dev

Rust was quite literally the most loved programming language by developers in a stack overflow survey

@@AchroDev How is it not a lot of BS? I write Rust code for a living and I hate doing it. If I could go back to writing C only I would be the happiest person in the world. Please, explain why is it that only the opinion of rustaceans matters and anything anyone else says is somehow void. Rust has been the number 1 most loved programming language in the SO community... ok, and? is the whole world only SO? wtf. 0 logic.

@@letsgetrusty I guess C devs don't exist and we're a product of imagination. Cool.