On Friday, 21 October 2022 at 07:37:41 UTC, Stefan Hertenberger wrote:

fn main() {
    let mut foo = 5;
    let bar = |val: &mut i32| {
        *val = 17;
    };
    let baz = |val: &mut i32| {
        *val = 42;
    };
    bar(&mut foo);
    println!("{}", &mut foo);
    baz(&mut foo);
    println!("{}", &mut foo);

}

Heh. You don't need closures, just use regular functions.

On Thursday, 20 October 2022 at 14:26:07 UTC, IGotD- wrote:

Useless or not, it is becoming a thing,

https://www.autosar.org/news-events/details/autosar-investigates-how-the-programming-language-rust-could-be-applied-in-adaptive-platform-context/

https://opensource.googleblog.com/2022/10/announcing-kataos-and-sparrow.html

https://azure.microsoft.com/en-us/blog/delivering-consistency-and-transparency-for-cloud-hardware-security/

https://techcommunity.microsoft.com/t5/internet-of-things-blog/previewing-rust-on-azure-sphere/ba-p/3494988

https://github.com/orgs/esp-rs/projects/1

https://www.eenewseurope.com/en/arm-joins-the-rust-foundation/

https://www.phoronix.com/news/Rust-Is-Merged-Linux-6.1

I could keep posting links about Rust's rise on the embedded space, but I think you got the point.

Naturally I also agree that systems programming languages with GC should be used, but unless we have a big name pushing them, affine type systems have won for low level systems coding.

On Friday, 21 October 2022 at 10:42:52 UTC, Paulo Pinto wrote:

Please stop saying it is an ecosystem issue. That is not they key thing that prevents adoption. This is just a sleeping pill that makes people go for apathy believing that they cannot change the trajectory. Which is wrong.

The main issue with D is not lacking an ecosystem, D has an ecosystem that can grow and that allows you to be productive in system level programming. System level programming does not require a gigantic eco system.

But D is adding new stuff to a code base that is difficult to evolve rather than focusing on design issues people complain about. The core difference is that C++ and Rust are clearly showing in their releases that they are working on compensating for design flaws that people care about.

The main issue for D is a lack of strategy that involves architecting a modern D compiler, that people want to work on, and an objective strategy for selecting design issues that needs to be addressed.

Without a solid strategy you can neither get rid of design issues or grow in a predictable manner. For an outsider D as a project looks more like a one-man-person-with-entourage than a cooperative effort. This does not grow confidence in the project.

Rust and C++ are much less about any singular entity, but more of a collaborative effort. That is good for confidence and for long term viability and evolution.

It is great for D that there is a foundation now, but has it really changed the structure of the project, and how strategies are formed, to any significant degree?

On Friday, 21 October 2022 at 10:16:10 UTC, Paulo Pinto wrote:

Not sure it will be Rust though.

In the new native language camp, Jai and Odin makes use of Scala-like "context" pointer passed to each function to pass around an allocator, a logger... being true to the monadic nature of allocation and logging. With an important difference there, Odin apparently uses a fixed context, and Jai a custom one where you can put anything.

Now THAT is an interesting feature to have for embedded.

On Friday, 21 October 2022 at 11:54:59 UTC, Guillaume Piolat wrote:

It is also not true. C/C++ are still completely dominating. Reactive systems are also done using special tools (functional style). Low level programming is not some narrow field that can be shoehorned into any singular dev environment.

Implicit context pointers have been suggested for Carbon too. (hidden parameter to functions)

On Friday, 21 October 2022 at 11:54:59 UTC, Guillaume Piolat wrote:

None of them have the industry backing at the same scale.