"In celebration of Marvel Studio’s Guardians of the Galaxy Volume 3, we temporarily re-launched Zune.net last month. We also took the opportunity to fix an issue that was causing some challenges in getting the original Zune drivers to install in Windows 11 with this build in the Canary Channel. So now it should be easier to use your (totally unsupported and still discontinued) Zune on Windows 11."
>(totally unsupported and still discontinued) Zune
So much for the "iPod killer". And then for the Windows Phone "iPhone killer" that replaced it. The tech press is so predictably wrong, with BS clickbait headlines.
I didn't get the point of using a Zune in the latest Guardians movie. Why the product placement for a product that's long discontinued? Microfot won't make any money if people go on ebay and buy a used Zune out of nostalgia. Or it wasn't a product placement after all?
>Why the product placement for a product that's long discontinued?
Not everything is a "product placement".
In this case it was a nostalgic, offbeat item, to funnily convey those things about the character that would use one, like the Walkman and music choice was in the first movie.
It'd be really exciting if they make a safe Rust API for kernel drivers. You can technically write a driver in Rust, but the bulk of your code will be interacting with the unsafe, complex C API, so it's a bit pointless.
One could make the same point about any rust that ultimately interfaces with the system using libc - all Rust programs at one point were interfacing with a lot of C code.
A more serious counter argument is that Mozilla did exactly this with Rust in Firefox - and it seems to be a success, there's still lots of Rust in the browser and it seemingly is working.
Point being, using Rust for all of the things will probably be painfully cumbersome today, but writing up a complicated enough component with a well defined boundary with the rest of the kernel will probably prove immensely useful and won't be painfully cumbersome.
And that unsafe, complex C API communicates with an even sketchier system made of registers, IO ports and nasty hardware details. Providing a higher level API for a nastier backend has always been a core feature of operating systems and programming languages.
Almost nothing is still I/O ports because it's more portable to use MMIO and if you're going to offer MMIO why bother also doing I/O ports. But yes, as a vague outline you're correct.
WIL is user mode, for applications. Drivers will use Kernel Mode Driver Framework or User Mode Driver Framework. UMDF has a COM style API.
C++ has been usable in the Windows kernel for a long time but you need to make sure that code ends up in the correct PE segment types for pageable and non pageable code and that there are no hidden gotchas for features like exception unwinding and that new can use paged or non paged pool appropriately. Same for Rust: getting to a nostd etc that is compatible with kernel use.
I think there’s a strong case that many drivers could be written with either a user mode driver framework or a small VM. Most of the hardware devices I’ve worked with we just need fast transfers of data to user mode buffers so our application can handle it, and the code is mostly boilerplate framework code plus setting up device registers to set up DMA transfers. I don’t see why that couldn’t be handled with say an EBPF or WASM equivalent byte code.
> wil was primarily developed by the Windows shell team for writing usermode code, but the NDIS and Bluetooth teams have contributed some small kernel-specific features. Here's a few examples of how you can use wil in your kernel driver:
You'd need some kind of formal model of the hardware for that to be feasible. A big part of doing driver development is writing strings of bits to hardware addresses over I2C, SPI, USB or other protocols.
Interesting Redstone build. That’s like Windows trunk, right? I wonder if the slew of unusually many and interesting updates is due to it eventually going to become Windows 12? They already have builds from that branch though (Gallium) although none as Insider Preview yet, so I’m unsure how it relates to these.
>> "Otherwise please use the original title, unless it is misleading or linkbait; don't editorialize."
Key bit: "unless it is misleading or linkbait"
Editing or even completely rewriting the title seems to be okay as long as it's accurate and not inciteful or opinionated. I've done it when there was no title or the title didn't say anything meaningful with no complaints.
Unpopular opinion, both MS and Linux should use Ada instead of Rust in the kernel. The rust language isn't stable enough and it does not force the programmer to do uncomfortable things to avoid logic errors (not memory or race condition). Ada had been tested for decades in life or death level critical systems and it is the better direction for the future.
I played with very little introductory programs only. SPARK is the formally verifiable subset of ada from what I recall but my suggestion was to use the ada (ada95?) supported by gcc which means there is no special setup needed other than configure gcc. Ada kernel modules have be written but I don't know if any were mainlined.
The Spark Ada safety critical subset is memory safe, but Ada isn't. It's possible to write a kernel in Spark, but hard to believe that you'd get buy-in from other kernel developers. Ada doesn't eliminate use after free, race conditions, or dereferencing null pointers[0]. Rust addresses these, so it's hard to see Ada as an improvement.
Yeah but.. Ada is boring, isn't it? I'd like to hear some opinions on that. But in any case, Rust is exciting and new, and therefore it's being adopted. Who wants to be spending their spare time on boring tech? Risk higher, but more fun.
"Hard to learn" ? Google found that when they trained engineers to write Rust the majority of engineers reported they were confident writing Rust in 2 months or less and a third reported they felt not merely confident but as productive as in other languages in that time. Google describes this as "in line" with numbers for other languages they've taught their engineers so apparently it's not especially "Hard to learn" compared to other languages used at Google.
The problem with this assertion is that it says a lot of different things, some of which I'd believe to be true, and some of which I do not.
> Shouldn’t readability/ understandability be a critical requirement for kernel code?
I don't think anyone is going to say "readability is not important," but the problem is that there's a looming question of "for whom"?
This is basically part of the issue here. You are making an incredibly broad generalization about a fairly complicated topic, one of which we don't even have a lot of evidence about, but many opinions.
Rust is hard/simple. The rules aren't complex. The constructs aren't complex. But it's hard to write because the rules are very restrictive.
Rust is also much easier to read than write (for a reader who understands the rules).
It's optimising for exactly the things you want in systems programming:
Easier to read than the write.
Simple rules that are easy to understand but hard to follow, and that produce simple programs.
Compare that to C which is easy/complex. It's much easier to write than to read. It's easy to learn and write but produces code that's very complex. The rules are all by convention instead of part of the type system.
That's pretty out of context. Before that, they say this:
> The rules aren't complex. The constructs aren't complex.
So yes, once you understand it, you understand it, but they also specifically said it's not hard to get to the point of understanding it. If we're going to assume that any out-of-context quote is equivalent to the entirety of the content, I'll just cite you on this one:
Its pretty easy to learn the rules. Once you've done that you can watch a game and know roughly what is happening. But its still a hard game to master.
> Maybe the answer for more secure kernel code is C with better security analysis tools?
Perhaps like a way of expressing the constraints of a program and automatically checking if portions of a program satisfy those constraints. Aka a type checker.
Type checkers are not enough and there are many constraints they can not check.
>C is not simple. It is small.
C is complex because of undefined/unspecified/implementation defined behaviour. Any language which is used on as wide of a range of platforms will have those issues.
> the relatively simple nature of C is what makes it suitable for large scale kernel development
the relatively simple nature of any language would make it suitable for ANY large scale development
I dont know why you attribute this to kernel development specifically. When you think about kernel development, the uniqe requirement is never "being simple". I would think it has something to do with being closer to bare metal and can do low level instructions performantly.
Hard to learn does not necessarily equate to hard to read. You don't need to learn to work with Rust's borrow checker to understand a bit of code, but figuring out how to change it might take longer.
"Windows NT is written in C and C++, with a very small amount written in assembly language. C is mostly used for the kernel code while C++ is mostly used for user-mode code. Assembly language is avoided where possible because it would impede portability."
> wil was primarily developed by the Windows shell team for writing usermode code, but the NDIS and Bluetooth teams have contributed some small kernel-specific features. Here's a few examples of how you can use wil in your kernel driver:
It's two different concepts. 1) hard to learn 2) hard to read/understand
I would argue rust is hard to learn, and not hard to read or understand once you know it. In my opinion, for example:
Hard to learn, easy to read: Rust
Easy to learn, hard to read: Perl
Hard to learn, hard to read: C++
Easy to learn, easy to read: Python
Even if you don't agree exactly with my opinions, you could maybe see the distinction between (easy/hard to learn) and (easy/hard to read, once you learned it).
I also think that 99% of the difficulty in learning rust is learning how to get to a compiled state. Once the binary is built, you can make a lot more assumptions about it than other binaries (for example, locations of crashes, overflows, ownership, memory freeing can all be detexted). Compare that to c or c++ where getting to a compiled state is way easier, but the resulting binary segfaults or other issues.
I think its more like 90% of language is simple and easy to learn whereas the rest 10% is complex and hard to learn (depending on your experience). You can do a lot just by using 90% of the language. This applies to other programming languages as well - some parts are easy and some are complex.
"In celebration of Marvel Studio’s Guardians of the Galaxy Volume 3, we temporarily re-launched Zune.net last month. We also took the opportunity to fix an issue that was causing some challenges in getting the original Zune drivers to install in Windows 11 with this build in the Canary Channel. So now it should be easier to use your (totally unsupported and still discontinued) Zune on Windows 11."