Paul Thurrott
banner
thurrott.bsky.social
Paul Thurrott
@thurrott.bsky.social
Personal technology, with a focus on productivity, mostly Microsoft.
Reposted by Paul Thurrott
New Podcast Episode:
Windows Weekly: Snow & Claus
Windows 11 & Agentic AI
with @leolaporte.me, @thurrott.bsky.social, @richcampbell.bsky.social
Windows Weekly: Snow & Claus | TWiT.TV
Pavan Davuluri only spoke at one Ignite 2025 session, and it did not deserve the hate he got. But what did he really say?
twit.tv
November 27, 2025 at 2:05 AM
Reposted by Paul Thurrott
Happy Thanksgiving @thurrott.bsky.social @bdsams.com I got to update this picture, huh?
November 27, 2025 at 8:17 PM
From the Editor’s Desk: Slop ⭐
AI deniers and critics have latched onto the term “AI slop” for obvious reasons, but human error is a far more serious problem, one that has led to countless disasters and untold loss of life. If you want to remove “slop” from the world, then the goal should be to automate everything with technology. And that technology will most certainly utilize AI. Some of the best (worst?) examples of human error include the sinking of the Titanic, the Chernobyl nuclear disaster, and the Exxon Valdez oil spill. But human error leads to disaster literally every single day in the form of automobile crashes. It is by far the biggest factor in airplane disasters and maritime accidents. And it plays a significant role in medical procedural errors too. How many sporting events have been decided by a missed call from some human referee or umpire? Too many, and that’s why each sport is increasing the use of video reviews. But let’s keep this to technology. From the CrowdStrike disaster to almost every single Microsoft security incident we’ve seen, it usually comes down to one thing, human error. And if you factor in indirect human error, as in the coder who wrote the buggy software that failed, as we should, then it’s even worse. Inserting a person into the chain of decision making is arguably one of the biggest mistakes one can make. And yet, that is what we’re calling for with AI. It’s like the feeblest person in the room demanding to make decisions for everyone else. We need to let go. I have been a car enthusiast for my entire life, and I stuck diligently to small, manual-shift vehicles for as long as I could despite the obvious downsides. I still believe that I’m a better driver than virtually everyone I encounter on the roads, especially here in Pennsylvania. But with our streets and highways now crowded with traffic at all hours, it’s pretty clear that no combination of laws, enforcement, and collective driving skill will ever solve this mess. What will solve it, of course, are autonomous vehicles. Which is precisely what an enthusiast like me would resist. Sometimes it’s difficult admitting that you’re part of the problem. We're so human. To head off the obvious counterpoints, yes, AI still has a way to go. I’m not sure that anyone watching the first Wright brothers flight could or would have foreseen prop airplanes, jets, or spaceships, but they certainly would have gazed in wonder at a thing that they had previously thought to be impossible. Today, you don’t need much of an imagination to see how AI will transform our lives. In some ways, you need more of an imagination to claim that it won’t. No matter. Despite ongoing improvements, AI will still make mistakes, it’s inevitable. As we rely on it more in ever more critical ways, lives will be lost. And each time this happens, the deniers and critics will explode like cockroaches from under the wood pile and complain bitterly that this is exac... The post From the Editor’s Desk: Slop ⭐ appeared first on Thurrott.com.
dlvr.it
December 2, 2025 at 5:03 PM
WinUIpad: Code Cleanup, “Needs to Be Saved” Indicator, More ⭐
In this update, a little code cleanup, a "Need to be Saved" indicator, and new minimum app window width and height settings. Remember, the latest version of the code is available on GitHub. A little code cleanup Given all the refactoring work I'd done on the WPF version of this app (.NETpad), I was never super comfortable with the quick and dirty approach I was taking to WinUIpad. But this was born of necessity: The Windows App SDK isn't just new to me, it's terrible, all kinds of terrible, and lots of things that just work in WPF don't work here. So this really is a rewrite in so many ways, and I've pushed forward in my unsophisticated way, hoping to brute force this thing into a basic app that actually works. But the goal has always been to clean up the code once it does work. And I've been trying to stamp down that annoying part of my brain that doesn't want to wait on doing that. But after I posted the previous update, timo47 provided me with some very useful feedback, some of which touches on my quick and dirty approach with the Windows App SDK. (And thanks again for that.) I would have gone through it regardless, but because this had been bothering me anyway, I was more eager to do so than I might have been otherwise. To be clear, I haven't cleaned up the entire program. But before I pushed the previous code update to GitHub, I had been experimenting with different types of state checks (it's possible I'm obsessed with app state), and though I knew that an unnecessary App-level state property I had created and then used in several places was still in there, I had let it go, figuring I would simply remove all that on the next pass. In making that change, I discovered that my use of this new property in the FileOpMenu_Click() event handler had caused an error that prevented the user from opening a document. So I pushed that change to GitHub as soon as I was sure I had reverted it correctly. Among other things, timo47 asked me why I was calling the (Main) Window's Close() event handler from the AppWindow's OnClosing() event handler. I wish I could answer that accurately, but it came out of what is now a familiar experience when working with the Windows App SDK: Nothing ever works, and so I find myself adding more and more code to try to get around whatever issue. And then I forget why I went down that particular rabbit hole. In this case, I was hoping to just create a single method that ran each time the user tried to close the app window, one that would check whether the document needed to be saved and, if so, then save (or save as) the document as needed or back out if the user cancelled. This proved impossible as I wrote in the previous post. And so I settled on two primary event handlers for app closing: OnClosing() in AppWindow and ExitMenu_Click(). I went through too many permutations of each to count or remember, but I did temporarily leave some commented out code in each that was from previous attempts. An... The post WinUIpad: Code Cleanup, “Needs to Be Saved” Indicator, More ⭐ appeared first on Thurrott.com.
dlvr.it
November 30, 2025 at 3:35 PM
WinUIpad: Word Count, Text Cursor Position, App Shutdown
I was hoping to keep this to weekly updates, but two weekends came and went with me struggling to figure out why WinUIpad was crashing on app exit in certain conditions. So another few weeks with the Windows App SDK and WinUI 3 was another few weeks of frustration, as always. But that’s the job, and this new update includes basic implementations of the Word count and Line and column position displays, plus one of the dumbest and most difficult tasks to do properly with this framework, app shutdown. Here’s what’s new. Word count Looking over my WinUIpad to-do list, I decided to tackle a few of what I felt would be the easier tasks. But as is so often the case with the Windows App SDK, I had mixed results. The simplest, perhaps, is the Word count display in the status bar: As the user types, I just need to update the count. This is a feature I added to the first, Windows Forms-based versions of .NETpad dating back to perhaps 2019. And it’s been in each version ever since. For this version of what’s now called WinUIpad, I decided to look at the code I had written or, in this case, obtained previously. And I found a March 2020 update to .NETpad that uses a regular expression to output the word count. Which is how I know I didn’t write it. You’ve heard the phrase that the best phone is the one you have with you. In a similar vein, the best code is often the code you don’t need to write. And though I’m sure I will revisit this later as part of an app-wide refactoring, the goal for now it not get stuck on details and to just get it done. So I went back to the well. As with previous versions of the app, a lot of the action takes place in the TextChanging() event handler for the main TextBox. Three things now happen when this event handler fires: It changes the Document object instance’s TextChanging property to True, changes the Document object instance’s Contents property to the TextBox’s Text contents, and, now, it also runs a new helper method called UpdateCount(). As for the new UpdateCount() method, this is based on the aforementioned 5+ year-old code. That TextBox has two event handlers (the other is SelectionChanged() and is discussed below), but UpdateCount() only needs to be called from here. So that’s that. For now. Line and column position This I haven’t completely solved, though I’ve left the code I have so far in there for now. The issue is that the Windows App SDK/WinUI 3 TextBox control doesn’t support WPF’s GetLineIndexFromCharacterIndex(), CaretIndex(), and GetCharacterIndexFromLineIndex() methods, and so you have to do all that work yourself. I know, crazy. Since WPF is open source, it’s possible to look at the source code for those three methods, but for now I am trying to just figure it out using GitHub Copilot, which is an endless circle jerk of errors when it comes to Windows App SDK/WinUI 3, and my own limited capabilities. Anyway, as per the Upda... The post WinUIpad: Word Count, Text Cursor Position, App Shutdown appeared first on Thurrott.com.
dlvr.it
November 27, 2025 at 7:48 PM