[Info-vax] Rust as a HS language, was: Re: Quiet?

[plugh]

"Chaos, Confusion, Disorder.... My work here is done." :)

To most of you who didn't really follow the original link, please favour my posting some interesting (to me) bits:

"The prior chapter walked through a Rust library and CLI tool in the service of introducing software security concepts. This chapter will focus on the Rust language proper - we'll tour its syntax, features, and conventions.
Now we won't be covering all of Rust. It's a big language. Much closer to C++ than C. Our favorite comprehensive Rust book, Programming Rust, is a 700+ page tome, a relentless enumeration of language features. Now it's a phenomenal book, and a major inspiration for this one. But we're talking multiple-Costco-mini-barrels-of-whole-bean-coffee kinds of endurance.
Part of the challenge is the sheer breadth of features Rust offers. Being a relatively new language, Rust has the benefit of hindsight: it's free to cherry-pick successful aspects of its predecessors.
This includes OCaml's algebraic data types, C++'s monomorphization, Scheme's hygienic macros, etc2. While the Rust Team strives for a cohesive design3, the language juggles several influences.
Fortunately for us, you don't need an exhaustive understanding of Rust to be productive in it. This section previews key concepts - just enough to get you started reading and writing Rust snippets. We'll cement those concepts in the rest of the book by building an embedded-friendly, high assurance library.
With that as a foundation, you'll be prepared to write your own real-world Rust programs. And to tackle learning additional language features (smart pointers, channels, async, macros, etc) as project needs arise.
Our tour of Rust will be broken into six short-ish parts:
    Low-Level Data Representation - primitives, tuples, arrays, references, and slices.
    High-level Data Representation - structs, enums, generics, and traits.
    Control Flow - conditional statements, loops, and pattern matching.
    Ownership Principles - understanding the core principles of Rust's most novel feature.
    Ownership in Practice - concepts for working with ownership day-to-day.
    Error Handling - propagating failures and/or maintaining availability."

-- https://highassurance.rs/chp3/_index.html

The reason for posting this topic on comp.os.vms is that this language allows one to write software that provably eliminates (!) certain classes of Undefined Behavior. I can't stress the importance of that to those of us whose still writing C

I posit that those interested in the intersection of such languages and VMS will find this a useful language, and worth their time to study. Even if it's not available on VMS