contextfree

> the maximum that consumer can afford.

but isn't that less for consumers who can afford less?

WPF has a datagrid control now, IIRC it was added in the second or third major version.

"designed for an 8 note system"

*7 note system

It's called an "octave" because the 8th note is considered another instance of the 1st.

https://bsky.app/profile/vgel.me calls it "Claudlish" which I prefer because it sounds funnier

This isn't so much a cmd thing as a fundamental Windows API thing. CreateProcess takes in the entire command line as a single string.

Powershell is a completely different model where native commands run in-process, you can import commands and invoke APIs from arbitrary .NET assemblies, and then the PS runtime handles all argument parsing (and many other things). But it also lets you invoke and interop with arbitrary command-line executables and then those do their own parsing like they always have.

On Windows, UWP was supposed to solve this (by blocking apps from taking focus directly, but having the OS/shell create an app window immediately on launch and give focus to it) but most apps aren't UWP apps.

Yes, trying to communicate (or watching others try to communicate) about these topics is incredibly frustrating because it's pretty much impossible to make any progress without interrogating people's different definitions, but nobody wants to do that because it would mean being pedantic, splitting hairs, etc.

Yeah I've written some docs using the following process:

1. Throw some notes, PR links, etc. into copilot and ask for a first draft

2. Go back and forth for a while asking for revisions

3. Trash all of the AI-generated text and rewrite the whole thing myself from scratch, which I can do quickly in a typing frenzy because I now have a clear idea what I want, by way of seeing what I don't want.

But I feel like over the last ~10 years there's been a trend back towards learning more about them (e.g., with Rust and new C# features, or with C++ Win32 programming becoming a cool hipster thing somehow)? Or maybe that's just my own personal bubble.

I still take a lot of handwritten notes? Sometimes while using AI even

Yeah, I've always tried to train myself to do calculations in my head as much as reasonably possible when learning about mathematical objects, etc. Like when I was learning linear algebra I made myself invert 4x4 matrices in my head. (Pen and paper is also cheating!) Calculators and computers have been better than me at this sort of thing for my entire life, so in some sense this isn't a change?

Metal Gear Solid 2 sort of

I guess the argument is that, while it's the same whether the user asks for "give me page 3" or "give me scrollbar Y coordinate 2160", the user is more likely to do the first or at least to care about the correctness of its result?

That is about consumer copilot not M365 copilot

Roslyn API basically lets you plug in to the C# compiler or use parts of it so that you can get the same view of the abstract syntax tree, typechecking, flow analysis, etc. that the compiler does. So it's a way to work with C# code at that level rather than just via textual manipulation. I'm less familiar with other languages but I think many have compilers with analogous capabilities, I know Haskell has the GHC API and I think the LLVM-based Clang (C++) and Rust compilers let you do similar things

A dumber but related habit I've gotten into is that if I want to use AI to do some sort of refactoring on a C# codebase, instead of asking it to edit the code directly I ask it to write a code transformation using the Roslyn compiler API, then run that on the code. The result is less likely to have subtle bugs if it appears to work and gets through a light code review on the transformation (i.e., attempts to cheat with weird special-casing are more likely to stand out amongst the Roslyn API code, and if there isn't such weird special-casing but the code is wrong, the result is more likely to be completely broken rather than subtly broken)

Seeing this makes me think of the controls from the original arcade version of Street Fighter 1.

Windows has been gradually "undocking" more and more stuff from the main OS install into separately updatable/restartable/etc components for a while.

The post doesn't really define the problem this is supposed to solve for "builders". FWIW, Microsoft's official attempt at solving this problem? seems to be "Windows developer configs" -> https://github.com/microsoft/WindowsDeveloperConfig

which is described as

A WinGet Configuration (DSC) file that sets up a clean, lightweight, distraction-free developer workstation. The goal is a PC state that devs actually love using: no clutter, no noise, just the tools you need. (...)

* A PC devs actually want to use. Clean Explorer, dark theme, no pop-ups, no recommendations, no widgets. Just your code and your tools. (...)

Windows doesn't have any modern version of .NET installed by default though, only old .NET Framework versions

They already have this problem, Windows includes .NET Framework 4.x but not any modern version of .NET

No he was correctly factoring in afterlife time dilation

WinUI2/UWP was heavily adopted internally though?* Most Windows shell UI and built-in apps use it at this point.

* (at least within the Windows organization; maybe not so much in other parts of Microsoft)

it's a reasonable-sounding inference (if your only context is that there's a "new" Media Player and it's taking more memory) that doesn't apply in this particular case.

A joke can be "funny because it's true"

I think Groove Music/Media Player is C# though

1. It does not use HTML/JS. It is a fully "native" app (at least if C# counts as native) written with C# and UWP/WinUI2 XAML. Actually, Xbox Music in Windows 8.x had a web tech based UI; when it was rebranded as Groove Music in Windows 10, its UI layer was rewritten. Xbox Music itself in turn was a reskin/rewrite of the UI layer of Zune (which was C++) so it's already been through full cycle of native->web->native. (The "new" Media Player still identifies as "ZuneMusic" in packaging metadata!)

2. it's not "after"; Groove Music was largely written in 2014-2017 in the early Windows 10 days, and even its rebrand as Media Player in Windows 11 happened in 2022, and it's barely been touched since then.

The Media Player the article about is a fully "native" app though (at least if you count C# as native). The Windows8.x version (Xbox Music) was web tech based; it in turn was a reskin/UI-layer-rewrite of Zune (which was C++), so they've already gone through a whole cycle of native->web->native with this. (The "new" Media Player still identifies as "ZuneMusic" in packaging metadata!)

The rebrand of Groove Music to Media Player was a Windows 11 thing, so it sort of did ship a "new" media player. It also still ships the old one though (as "Windows Media Player Legacy")

This app is a reskinned Groove Music, it was mostly written back in the early Windows 10 days (2014-2017) and long predates Copilot/etc. Even the Windows 11 rebrand as Media Player (2022?) predates that stuff, and it's barely been touched since then.

It doesn't use JS/TS, it's a reskinned Groove Music and is all either C++ or C# (I think C#) + UWP/WinUI2 XAML

Xbox Music in Windows 8.x was actually web tech based, but was rewritten into C# and XAML when it was turned into Groove Music in Windows 10