chris anderson

Wrangling agents, writing code, building products
VP, Eng @ Microsoft

[chris anderson @codemonkeychris]

Alexandre's been working on Reactor for the past several months and made some big improvements... Exciting to see him take the pen. Take a read!

[Alexandre Chohfi @ Microsoft @AlexandreChohfi]

var (count, setCount) = UseState(0);

...in a #WinUI app. 👀

What if building Windows apps felt like React or SwiftUI, in plain C#? That's the experiment behind Microsoft.UI.Reactor: real native controls, no XAML required, and it's all open source!

https://t.co/V7Zr0nQIa5

[chris anderson @codemonkeychris]

Excited to see more progress on Reactor!

[.Morten 🪁 @dotMorten]

Microsoft.UI.Reactor: a C#-first way to build #WinUI apps: https://t.co/6drcdcAq0Z

[chris anderson @codemonkeychris]

This looks quite interesting to me... please give Clint feedback if we should include in powertoys or not!

I vote yes!

[Clint Rutkas @ClintRutkas]

PowerToys worthy? Dev Storage Manager - currently a prototype. What is taking space, make a dev drive in 2 clicks, benchmark builds, move caches, ...

Would love thoughts.

Stressing POC, UX is still a mess but scans my computer in ~4 seconds with over 1.4 million files

[chris anderson @codemonkeychris]

Dave understand the depths... it's good to step back once an a while, I get caught up in all the warts - it's easy to find the faults, this post brings me joy.

[Dave W Plummer @davepl1968]

Happy Birthday, Windows 11... It's an amazing operating system with massive power just below the surface.

I would change and add many things, but there are many, many more I wouldn't. These are the hidden gems, pieces of Windows that people take for granted.

Like the subsystem model. Win32 was never the operating system. It was a personality bolted onto NT, same as the old OS/2 and POSIX subsystems. That design decision from 1993 is why WSL exists at all. WSL1 ran Linux binaries as pico processes against a translation layer; WSL2 runs a real Linux kernel in a utility VM, and your distro still shows up as a normal Windows process tree you can attach a debugger to. People treat that as a feature. It is Dave Cutler's subsystem idea, still paying rent thirty years later.

ACLs on every object, not just files. A process, a thread, a section, an event, a mutant, a token, a job — each one carries a security descriptor. The Object Manager doesn't special-case "files get security, everything else is a free-for-all." Open a handle and the Security Reference Monitor checks the ACL. That is why you can lock down a named pipe, a registry key, or another process with the same model, and why "run as" and restricted tokens actually mean something.

The Object Manager itself. One namespace. \Device, \BaseNamedObjects, \Sessions, \Registry.

Handles, reference counts, and a consistent lifetime model for almost everything the kernel exposes. Most of what you think of as "Windows APIs" is a user-mode wrapper over an object you opened by name or by inheritance.

I/O completion ports and the I/O manager. Overlapped I/O is not a later bolt-on. IRPs, cancel routines, and a completion port that a thread pool can drain are how a service handles tens of thousands of sockets without a thread per connection.

NTFS sits on the same path: journaling, the USN change journal, reparse points, sparse files, hard links, transactions when you want them. Cloud placeholders and symlinks are reparse points. They are not a hack layered on later.

Job objects. A process is not the unit of resource control. A job is. CPU rate, memory, I/O, kill-on-close, nested jobs. Windows containers and a lot of sandboxing are just job objects with a nicer hat.

ALPC for the cross-process calls you never see. Services, RPC, COM activation, the window manager talking to win32k — local procedure calls with security context carried along, not a pile of ad-hoc shared memory.

And under it all, a type-1 hypervisor. The root partition is a guest. VBS, HVCI, Credential Guard, and the WSL2 VM are the same machinery. Memory integrity and isolated LSASS are not apps. They are partitions the kernel agreed to live beside.

None of this shows up in a screenshot. It is why the thing still runs software from the 90s, a Linux toolchain, a GPU game, and a hypervisor-isolated credential store on the same box without each of those being a separate product. The shell can be argued with. The executive underneath it is the part I would keep.

You could slap a new face on it tomorrow, and it would look entirely fresh while being incredibly stable thanks to 30+ years of dedicated engineering.

[chris anderson @codemonkeychris]

100% approved

[Ryan Healy @HeyHealy]

Today I'm coining a new internet slang term:

ai;dr

AI, didn't read.

Start using this to reply to comments that are obviously written by AI and watch what happens.

[chris anderson @codemonkeychris]

Containers for AI tools, and more. I've used MXC for safe running of generated EXEs, but you can use it for anything. Inspirations was agentic tools isolated securely on your machine.

Congratulations to the team on this milestone! v1.0.0!

Releases · microsoft/mxc

[chris anderson @codemonkeychris]

https://t.co/z0W1vKEZkY

Very excited that the WinUI team has migrated to working primarily in Github! We have more progress to make here, but it's great to see the team get more aligned with the OSS community!

[chris anderson @codemonkeychris]

@brinkzapp

[chris anderson @codemonkeychris]

https://t.co/cVpdxbAB6X

Getting agents to understand WinUI is important, we recognize that they are trained so much better for other libraries out of the box. With this new set of skills we are optimizing for creating the best UX as efficiently as possible with a coding agent!

[chris anderson @codemonkeychris]

@SheltonLouisGT each render creates the full C# graph (POCO) and diffs, to do the smallest update to the WinUI (WinRT) DOM.

[chris anderson @codemonkeychris]

Fun stuff, working on C# & Rust programming model for WinUI... very experimental, trying to do the development in the open. Would love feedback.

C#: https://t.co/vMjb3soqQm
Rust: https://t.co/Vdb9XW1gXg

[chris anderson @codemonkeychris]

@dotMorten @nqtspinner should be fixed: https://t.co/TQe4MrUHbm

[chris anderson @codemonkeychris]

@dotMorten @nqtspinner investigating...

[chris anderson @codemonkeychris]

@nkanauzu starting to work with the C# team on lang design issues, have 1 proposal live (factory initializers). I haven't hit any runtime issues (yet).

[chris anderson @codemonkeychris]

With Microsoft.UI.Reactor we ended up doing a diffing approach, for one primary reason - we wanted to start with the assumption of an unchanging language (C#) and desire for ergonomic programming. If you either compromise on these fine grained tracking may be better.

[chris anderson @codemonkeychris]

@dotMorten @ABM_Prottoy That's so cool!!

[chris anderson @codemonkeychris]

I fully expect we will change 100% of the API surface area in Reactor, moving from fluent to record creation, or even moving from diffing to dependency tracking.

https://t.co/vMjb3soqQm

[chris anderson @codemonkeychris]

For our experiment, we wanted to achieve two things; a ergonomic modern API that worked for humans and agents, and to authentically target WinUI (no new framework!).

[chris anderson @codemonkeychris]

SwiftUI exposes a fine grained programming model, React exposes a diffing solution. You can find a lots of examples on both sides of the fence. Each has pros and cons, typical workloads where one "wins" over the other (and different definition of win, of course).

[chris anderson @codemonkeychris]

Coarse grained diffing is where you generally let ignorant code run and then you compare the output of what it last produced and just produced, and then you make updates to some output (typically stateful DOM).

[chris anderson @codemonkeychris]

Fine grained is where you track dependencies and (ideally) they result. The system can deterministically say that if input I1 changes then we need to re-run functions F1, F3, and F8, which will change results R4.

[chris anderson @codemonkeychris]

I've worked on a couple reactive/functional systems. I think they generally break down into fine grained tracking or coarse grained diffing.