The Old New Thing
Practical development throughout the evolution of Windows.
Latest posts
Defending against exceptions in a scope_exit RAII type
But maybe it's not worth it.
Another crash caused by uninstaller code injection into Explorer
Inadvertently destroying a staircase while standing on it.
Mapping the page tables into memory via the page tables
So-called "fractal page mapping".
Sure, xor’ing a register with itself is the idiom for zeroing it out, but why not sub?
Somehow xor became the most popular version.
How did code handle 24-bit-per-pixel formats when using video cards with bank-switched memory?
You still have to use aligned accesses, even though the pixels might not be aligned.
Forgotten message from the past: LB_INITSTORAGE
Preallocating memory to avoid quadratic behavior.
What’s up with window message 0x0091? We’re getting it with unexpected parameters
Trespassing on system messages.
Why is there a long delay between a thread exiting and the WaitForSingleObject returning?
Maybe it didn't really exit.
Why was there a red telephone at every receptionist desk?
Not a direct line to Bill Gates's office.
Finding a duplicated item in an array of N integers in the range 1 to N − 1
Taking advantage of special characteristics of the array.
How do you add or remove a handle from an active WaitForMultipleObjects?, part 2
Waiting for the waiting thread to acknowledge the change.
How do you add or remove a handle from an active WaitForMultipleObjects?
You can't, but you can cooperate with the other thread.
How do you add or remove a handle from an active MsgWaitForMultipleObjects?
You can't, but you can arrange for the waiter to do it for you.
Were there any Windows 3.1 programs that were so incompatible with Windows 95 that there was no point trying to patch them?
The permanently ineligible list.
Learning to read C++ compiler errors: Illegal use of -> when there is no -> in sight
If the compiler is complaining about things you didn't write, find out who wrote them.
How can I use ReadDirectoryChangesW to know when someone is copying a file out of the directory?
File copying is not a fundamental operation, nor is it even detectable at the file system layer.
Why doesn’t the system let you declare your own messages to have the same semantics as WM_COPYDATA ?
Tempting but misleading.
The cover of C++: The Programming Language raises questions not answered by the cover
What are we reading about here?
Before you check if an update caused your problem, check that it wasn’t a problem before the update
It was going to be like that when I got here.
A question about the maximimum number of values in a registry key raises questions about the question
Why is this even a question?
What if a dialog wants to intercept its own message loop?
You can steal them from your owner.
Why doesn’t WM_ENTERIDLE work if the dialog box is a MessageBox?
Because it opted out.
How can I change a dialog box’s message loop to do a MsgWaitForMultipleObjects instead of GetMessage?
The dialog box lets you change how it waits.
Windows 95 defenses against installers that overwrite a file with an older version
A very primitive version of recovery.
How can I make sure the anti-malware software doesn’t terminate my custom service?
You'll have to ask nicely.
Windows stack limit checking retrospective: arm64, also known as AArch64
Wrapping things up.
Windows stack limit checking retrospective: amd64, also known as x86-64
Reaching the modern day.
Windows stack limit checking retrospective: Alpha AXP
Double the size, double the fun.
Windows stack limit checking retrospective: x86-32 also known as i386, second try
Appeasing the invisible return address predictor.
Windows stack limit checking retrospective: PowerPC
Doing the math backwards.
Windows stack limit checking retrospective: MIPS
Optimizing out the unnecessary probes comes with its own complexity.
Windows stack limit checking retrospective: x86-32, also known as i386
One of the weirdest calling conventions you'll see.
How do compilers ensure that large stack allocations do not skip over the guard page?
Don't take steps that are too large.
A snappy answer when asked about dressing casually at IBM
Oh, this old thing?
The fine print giveth and the bold print taketh away: The countdown timer
Think fast, no pressure.
Learning to read C++ compiler errors: Ambiguous overloaded operator
Look for the conflicting definitions to see where they are coming from.
When ReadDirectoryChangesW reports that a deletion occurred, how can I learn more about the deleted thing?
It's already gone. If you need more information, you should have been remembering it.
The mystery of the posted message that was dispatched before reaching the main message loop
Perhaps it's because you dispatched it.
Aha, I found a counterexample to the documentation that says that QueryPerformanceCounter never fails
Of course, anything can happen if you break the rules.
Just for fun: A survey of write protect notches on floppy disks and other media
Just some useless trivia.
What sort of horrible things happen if my dialog has a non-button with the control ID of IDCANCEL?
You get notifications that might not make sense.
Intercepting messages inside IsDialogMessage, fine-tuning the message filter
Making sure it triggers when you need it, and not when you don't.
Intercepting messages inside IsDialogMessage, installing the message filter
Using an <CODE>IsDialogMessage</CODE> extension point.
Intercepting messages before IsDialogMessage can process them
Process the message before you let <CODE>IsDialogMessage</CODE> see it.
Customizing the ways the dialog manager dismisses itself: Isolating the Close pathway
Intercepting the flow in your message loop.
Customizing the ways the dialog manager dismisses itself: Detecting the ESC key, second (failed) attempt
Sniffing the synchronous keyboard state is still not precise enough.
The 2026/2027 Seattle Symphony subscription season at a glance
The pocket reference guide for 2026/2027.
Customizing the ways the dialog manager dismisses itself: Detecting the ESC key, first (failed) attempt
Sniffing the asynchronous keyboard state.
Exploring the signals the dialog manager uses for dismissing a dialog
Summarizing the flow.
Could WriteProcessMemory be made faster by avoiding the intermediate buffer?
I guess it could, but why bother?
Microspeak: Escrow
Final build, final, final, final 2, ship this one.
It rather involved being on the other side of the airtight hatchway: Tricking(?) a program into reading files
Is it really a trick when reading the file is the purpose of the program?
How can I distinguish between the numeric keypad 0 and the top-row 0 in the WM_CHAR message?
See if it matches the scan code.
How can I distinguish between the numeric keypad 0 and the top-row 0 in the WM_KEYDOWN message?
Check whether it is an extended key.
How do I suppress the hover effects when I put a Win32 common controls ListView in single-click mode?
You can prevent the item from becoming hot-tracked.
How did Windows 95 get permission to put the Weezer video Buddy Holly on the CD?
Asking nicely, and asking a lot of people.
What should I do if a wait call reports WAIT_ABANDONED ?
It's your one chance to make amends.
How can I prevent the user from changing the widths of ListView columns in version 5 of the common controls?, part 2
Preventing the resize cursor from appearing.
How can I prevent the user from changing the widths of ListView columns in version 5 of the common controls?
Deny changes to the width.
Super Bowl LX creates an opportunity for symphonic friendly wagering
Betting classical music.
How can I prevent the user from changing the widths of ListView columns?
You can ask the header to be non-resizing.
Some small stories about the giant satellite dish antenna that was behind Microsoft Building 11
A little trivia.
Studying compiler error messages closely: Input file paths
Are you even compiling the correct file?
Why not store the SAFEARRAY reference count as a hidden allocation next to the SAFEARRAY?
The case of "Bring your own <CODE>SAFEARRAY</CODE>."
How can I retain access to the data in a SAFEARRAY after my method returns?
Find a way to take ownership.
Why did I lose the data even though I called SafeArrayAddRef?
You have to use the original pointer, but even that won't be good enough.
A digression on the design and implementation of SafeArrayAddRef and extending APIs in general
The concerns when adding a feature to an existing API.
What’s the difference between SafeArrayAccessData and SafeArrayAddRef?
Two ways of preserving the data.
C++ has scope_exit for running code at scope exit. C# says “We have scope_exit at home.”
You can wrap it in an <CODE>IDisposable</CODE>.
A simple helper function for attaching a progress handler to a Windows Runtime IAsyncActionWithProgress or IAsyncOperationWithProgress
It doesn't do much, but it saves typing.
On the proper usage of a custom Win32 dialog class
You are replacing the window procedure, not the dialog procedure.
Microspeak: On fire, putting out fires
Dealing with emergencies.
What was the secret sauce that allows for a faster restart of Windows 95 if you hold the shift key?
An old flag from 16-bit Windows.
How can I get the tab index number from a dialog box control?
The tab index number is an authoring concept, not a runtime concept.
When programs assume that the system will never change, episode 4: Stealing strings
The strings are an implementation detail.
Clipping the focus item when looking for its on-screen location, part 3
Finding <I>all</I> the clipping parents.
Clipping the focus item when looking for its on-screen location, part 2
Finding the correct clipping parent.
Clipping the focus item when looking for its on-screen location
Preventing the cursor from pointing to nothing.
Using Active Accessibility to find out where the focus item is
Looking at child objects.
Using Active Accessibility to find out where the Windows caret is
It's old and rather simple, but we like simple.
How can I find out where the Windows caret is?
You'll have go to a larger scope.
Swapping two blocks of memory that reside inside a larger block, in constant memory, refinement
Could do with a little less rotating.
How can you swap two non-adjacent blocks of memory using only forward iterators?
Applying the rotation trick to our new problem.
How can you swap two adjacent blocks of memory using only forward iterators?
A different algorithm, employing a different kind of cleverness.
Swapping two blocks of memory that reside inside a larger block, in constant memory
A variation on the constant-memory rotation.
2025 year-end link clearance
Another year gets relegated to history.
Understanding and mitigating a stack overflow in our task sequencer
The recurring problem of synchronous resumption.
Additional notes on color-keyed overlays as a way of doing smooth video rendering
Choosing the color-key and other brief discussions.
The Gävle Goat (Gävlebocken) succumbs in 2025 to a new menace
You could blow me over.
How can I detect that the system is running low on memory? Or that my job is running low on memory?
You can register for a memory notification.
Why are we worried about memory access semantics? Full barriers should be enough for anybody
You have to find new ways of going faster.
Reading the fine print, episode 4: Holiday promotions
Checking those validity dates.
Why is the last letter of my string not making it to the clipboard?
The struggle for null termination.
Why does my Ctrl+M accelerator key activate when I press the Enter key?
Understanding the difference between keys and characters for accelerators.
When irate product support customers demand to speak to Bill Gates
So transfer them to his office, or so it seems.
All the other cool languages have try…finally. C++ says “We have try…finally at home.”
The destructor serves as the "finally".
A shortcut gives me a weird path for a program shortcut that doesn’t point to the executable, so what is it?
It's a placeholder because the shortcut is to an MSI application.
Concluding thoughts on our deep dive into Windows clipboard text conversion
Stick to Unicode and you'll be fine.
Deducing the consequences of Windows clipboard text formats on UTF-8
Working out the implications.
Why is the Windows clipboard taking the scenic route when converting from CF_TEXT to CF_OEMTEXT ?
Something is forcing it down an alternate path.
Misunderstanding what the Cricket Celebration Bowl is
Apparently, not a bowl of crickets.
The Windows clipboard automatic text conversion algorithm is path-dependent
When the journey is not half of the fun.
Resolving an ambiguity in the Windows clipboard automated text conversion table
Who goes first?
Studying the various locale mismatch scenarios in Windows clipboard text format synthesis
If they don't match, then the 8-bit strings are basically broken already.
How does Windows synthesize the CF_LOCALE clipboard format?
Getting it from a place that might have been obvious in the past, but maybe not today.
How does Windows synthesize CF_UNICODETEXT from CF_TEXT and vice versa?
Let's ask the locale.
How does Windows synthesize CF_OEMTEXT from CF_TEXT and vice versa?
Starting with the easy case, or at least it looks easy.
How can my process read its own standard output?
You'll have to trick yourself before anybody notices, which may not be possible.
How can I read the standard output of an already-running process?
You can't. You'll have to do it before the process starts.
How do I check whether the user has permission to create files in a directory?
Request the directory security attributes that correspond to your proposed operation.
Microspeak: Big rocks
The large obstacles.
How do I get my edit control text to be autoselected when I choose it to be the default focus in my dialog?
Remembering some old APIs.
How can I have a Win32 drop-down combo box with a read-only edit control?
You can ask for its handle and mark it read-only.
Message-only windows are for messaging, not as a convenient victim for hosting UI
If you want to host UI, use a real window (possibly hidden).
At what point in the Windows development cycle is it too late to change the text of a translatable string?
The translation team sets the deadline.
The apocryphal origins of the Hot Dog Stand color scheme
Challenge accepted.
Why does XAML break down when I have an element that is half a billion pixels tall?
You've far exceeded the design goals and have even exceeded the expressive ability of a float.
Maybe somebody can explain to me how weak references solve the ODR problem
I don't see it.
In the commit-on-demand pattern, what happens if an access violation straddles multiple pages?
The access violation exceptions will continue until commit improves.
Is WriteProcessMemory faster than shared memory for transferring data between two processes?
Shared memory is the copy-free solution.
Microspeak: Little-r
Harkening back to a very old mail program.
How can I detect that Windows is running in S-Mode, redux
Doing it on hard mode.
I can use WM_COPYDATA to send a block of data to another window, but how does it send data back?
They can send it back with their own <CODE>WM_<WBR>COPYDATA</CODE> message, or they can put it in an agreed-upon shared location.
Could we use CTAD to simplify the use of WRL’s Callback function?
Not directly, but maybe indirectly.
Non-recursively deleting a binary tree in constant space: Rotating the tree
Preserving in-order while linearizing.
Behind the scenes on how Windows 95 application compatibility patched broken programs
Replacing bytes with the greatest of care.
How did Windows 3.1 distinguish two different programs that happened to share the same executable name?
The trouble with disambiguation.
Non-recursively deleting a binary tree in constant space: Restructuring the tree
Changing the tree structure to make it easier to delete.
Non-recursively deleting a binary tree in constant space: Synthesizing the parent pointer
Making one as you go.
Non-recursively deleting a binary tree in constant space: Traversal with parent pointers
First assume that you have a parent pointer.
The Microsoft SoftCard for the Apple II: Getting two processors to share the same memory
Reportedly Microsoft's first hardware product.
Why does SHFormatDateTime take an unaligned FILETIME?
Designed for its original use case.
Microspeak: turn into a pumpkin
To disappear, such as for the year-end holidays.
Trying to build a XAML tree in code throws a “No installed components were detected” exception
An unfortunate error code collision, but the explanatory text leads the way.
What to do when you have a crash in the runtime control flow guard check
You don't have to understand it, but you should be able to extract data from it.
How did the Windows 95 user interface code get brought to the Windows NT code base?
Ported bit by bit.
Dubious security vulnerability: Denial of service by loading a very large file
I mean, it's what you asked it to do.
The early history of the Windows Runtime PropertyValue and why there is a PropertyType.Inspectable that is never used
It used to be there because PropertyValue started out as the fundamental variant type before shifting focus to being the fundamental boxed type.
Windows Runtime design principle: Properties can be set in any order
If all you're doing is setting properties, you can do it any way you like.
What makes cheap_steady_clock faster than std::chrono::high_resolution_clock ?
It's quite a bit faster, though maybe you don't care.
Microspeak: The hockey stick on wheels
You're always a year away.
What about the icons in pifmgr.dll?
Just for fun.
Using RAII to remedy a defect where not all code paths performed required exit actions, follow-up
If the callback requires copyability.
Using RAII to remedy a defect where not all code paths performed required exit actions
Passing the obligation onward.
Why can you increment a reference count with relaxed semantics, but you have to decrement with release semantics?
It's more important to clean up when you leave.
I remember taking a screen shot of a video, and when I opened it in Paint, the video was playing in it! What witchcraft is this?
You copied the green screen.
API design principle: Don’t tempt people to divide by zero
Remove it from the equation.
The self-assignment principle for Windows Runtime properties: Don’t change behavior based on whether a property has been written to
The fact that a property has been set does not by itself trigger functionality.
The self-assignment principle for Windows Runtime properties applies to default values
The default value must be legal.
Windows Runtime API design principles around read-write properties: Idempotence and self-assignment
Setting it to the value it already has is not a crime.
Remembering the end of support for VRML in Internet Explorer
No one left standing.
Code comments should apply to the state of the system at the point the comment “executes”
Putting them in the flow.
Can we get weak functions for static linking? The Visual C++ compiler says “We have weak functions at home”
It's already there, just under a different paradigm.
The problem with inferring from a function call operator is that there may be more than one
<CODE>auto</CODE> parameters make this easy to write, particularly for lambdas.
How do I convert a FILETIME to a C++ clock like std::system_clock or winrt::clock?
The <CODE>winrt::clock</CODE> has a conversion for you.
Microspeak: Convicted
False backformation.
How can I enumerate the overflow icons in the Notification Area without showing them?
If they aren't shown, then they aren't automatable, so there's no requirement that they exist in the UI automation tree.
Why didn’t Windows 95 setup install a miniature Windows 95 so that it could be written as a 32-bit program?
Getting to the GUI quickly, and rebooting only once.
Samples note: Use comments to describe what code does, not what you wish the code would do
Comments explain the code. They are not substitutes for the code.
Why is Windows still tinkering with critical sections?
The critical section may be an old dog, but it's still learning new tricks.
Another lesson learned from the Windows 98 on-stage USB blue screen
Test before using.
Why was Windows 3.0’s WinHelp called an online help system when it ran offline?
It was online in a different sense.
Learning to read C++ compiler errors: Not a legal base class
What would make it an illegal base class?
Can I close a duplicate handle while I’m waiting on the original?
That's fine, since you're not closing the handle that you're waiting on.
How can I get my shell thumbnail extractors to run in the same process?
Adding another level of indirection.
Translating the STATUS_STACK_BUFFER_OVERRUN status code into customer-ready text
Reducing the level of alarm.
Why is the name of the Microsoft Wireless Notebook Presenter Mouse 8000 hard-coded into the Bluetooth drivers?
Is it some sort of favoritism?
How can I convert a third party in-process server so it runs in the COM surrogate?
You can put your own object in the surrogate first.
Why can’t std::apply figure out which overload I intend to use? Only one of then will work!
The overload resolution happens before the compiler knows what it's going to be used for.
The documentation says that CompanyName version information is required, but my program seems to work without it, so how required is it?
It's more of a "Very strongly recommended" than a "Required".
A suggestion to people who assign nicknames to meeting rooms
Lean into the pattern. Don't try to cross it up.
Why didn’t Windows 95 simply special-case the laptops that locked up when it executed the HLT instruction?
The catastrophic risk of bricking a computer.
The case of the crash on a null pointer even though we checked it for null
Understanding what you're checking.
How can I write a C++/WinRT IAsyncOperation<T> where T is not a Windows Runtime type?, part 2
Safer smuggling.
How can I write a C++/WinRT IAsyncOperation<T> where T is not a Windows Runtime type?, part 1
It's not representable in the Windows Runtime, but you can smuggle it.
Dubious security vulnerability: Remembering passwords for recently-opened ZIP files
If it didn't remember them, you wouldn't like it.
Thoughts on creating a tracking pointer class, part 16: Second attempt to use a list
We can splice nodes to move them between lists.
Thoughts on creating a tracking pointer class, part 15: A custom shared pointer
Simplifying it for out limited use case.
Thoughts on creating a tracking pointer class, part 14: Nonthrowing moves with the shared tracking pointer
Moving the exception somewhere else.
Thoughts on creating a tracking pointer class, part 13: Restoring the strong exception guarantee
Don't commit to anything until you know you can finish the job.
Thoughts on creating a tracking pointer class, part 12: A shared tracking pointer
Sharing a single tracking pointer among all instances.
Thoughts on creating a tracking pointer class, part 11: Repairing assignment
Restoring things that were automatically deleted.
Thoughts on creating a tracking pointer class, part 10: Proper conversion
Making sure you cannot remove qualifiers.
Thoughts on creating a tracking pointer class, part 9: Conversion
Making a read-only tracking pointer from a read-write tracking pointer.
Thoughts on creating a tracking pointer class, part 8: Tracking const objects
Making tracking pointers to const objects.
Thoughts on creating a tracking pointer class, part 7: Non-modifying trackers, second try
Another attempt to make tracking pointers to objects that you can't modify.
Thoughts on creating a tracking pointer class, part 6: Non-modifying trackers
Making tracking pointers to objects that you can't modify.
Thoughts on creating a tracking pointer class, part 5: Copying our tracking pointer
How to copy from a const tracking pointer.
Thoughts on creating a tracking pointer class, part 4: Using a circular doubly linked list
Building our own circular doubly-linked list.
Thoughts on creating a tracking pointer class, part 3: Using a std::vector
Tracking your trackers with a vector.
Thoughts on creating a tracking pointer class, part 2: Using a std::list
Tracking your trackers with a <CODE>std::list</CODE>.
Thoughts on creating a tracking pointer class, part 1: Concept art
Following an object as it moves.
Under what conditions could a ReadFile or WriteFile fail to transfer all of the bytes, and how do I detect that?
If there is not enough data to read, or not room to write.
How can I detect that Windows is running in S-Mode?
Check the code integrity policy.
How do I disable pieces of the property sheet for a service in the Services MMC snap-in?
There's no secret setting. It's all based on access control.
Why are Windows semiannual updates named H1 and H2?
To address an unconscious bias.
How can I read more than 4GB of data from a file in a single call to ReadFile?
You can't, but you can try to fake it.
Two related questions about keeping track of PIDs of IPC clients
Since you're doing IPC, you may as well let IPC do the work for you.
A consequence of the weird wReserved value at the start of the DECIMAL structure
It overwrites things by accident.
In C++/WinRT, how can I await multiple coroutines and capture the results?, part 0
If you don't really care about what happens if something goes wrong.
Why is there a window with no name blocking Windows shutdown?
They never expected you to see it.
API design note: Don’t make up multiple names for the same thing
It may be obvious to you, but that's because you wrote it.
How can I confirm in the Windows debugger that I’m looking at a COMDAT-folded function?
Ask for all the names for an address.
How can I wait until a named object (say a mutex) is created?
You can't, but maybe you can wait for something else.
Exploring possible solutions to the inconsistency in how Windows searches case-insensitively for named resources
Maintaining compatibility while addressing flaws.
Being more adamant about reporting that C++/WinRT was unable to resume execution on a dispatcher thread
Better versions in a different box.
What happens if C++/WinRT is unable to resume execution on a dispatcher thread?
What you get out of the box.
The case of the invalid instruction exception on an instruction that should never have executed
I don't recall ever asking you to do that.
If the Window Runtime PropertyValue is for boxing non-inspectables, why is there a PropertyValue.CreateInspectable?
For completeness, but not for functionality.
The Fundamental Failure-Mode Theorem: Systems lie about their proper functioning
It doesn't say what it does on the tin.
Perhaps not a recommended usage for an emergency power outlet
Maybe that's not a critical system.
There is a std::chrono::high_resolution_clock , but no low_resolution_clock
For when you care only enough to be roughly on time.
Detecting and reporting all unhandled C++ exceptions as well as all unhandled structured exceptions
Closing another exit point.
Our first attempt to detect and report all unhandled C++ exceptions as well as all unhandled structured exceptions
Identifying and classifying the exit points.
When I install an unhandled structured exception filter, why doesn’t std::terminate get called?
You're using the same hook that the compiler uses to call <CODE>std::<WBR>terminate</CODE>.
A walkthrough of the original Microsoft Building 3
Don't get lost on your walk down memory lane.
Dubious security vulnerability: If I perform this complex series of manual steps, I can crash a program I am running
What security boundary did you cross?
Why doesn’t LVIF_INDENT work without an image list?
Its original client had an image list.
German language cheat sheet: On changing quantities
How much there is, and how is it changing.
If the FormatMessage function fails, and I requested that it allocate a buffer, do I have to free the buffer?
There was no buffer returned, so there's nothing to free anyway.
Unintended yet somehow entirely expected consequences of marking a COM interface as local
If it's local-only, then it can't be remote.
The sizzle reel that says things that nobody understands
Failing to understand your audience.
2025 mid-year link clearance
Halfway there.
Embracing the power of the empty set in API design: Requesting zero items
It's okay to ask for nothing. You get nothing.
Why do I get errors or warnings about some weird symbol called ?main@@YAHP$01E$AAV?$Array@PE$AAVString@Platform…, part 3
Forcing <CODE>main</CODE> to be found in the place we want.
Why do I get errors about some weird symbol called ?main@@YAHP$01E$AAV?$Array@PE$AAVString@Platform…, part 2
Figuring out why C++/CX makes a difference.
Your information has been permanently deleted, for small values of permanently
Is it really gone?
Why do I get errors about some weird symbol called ?main@@YAHP$01E$AAV?$Array@PE$AAVString@Platform…, part 1
Welcome to the world of C++/CX. Is "welcome" the right word?
Abusing copyright strings to trick software into thinking it’s running on your competitor’s PC
I did technically cross my fingers.
The MIDL compiler still has trouble with double greater-than signs, sadly
Many have tried.
The case of the invalid handle error when a handle is closed while a thread is waiting on it
You are theorizing one race but experiencing another.
Learning to read C++ compiler errors: Ambiguous symbol errors after including a header file
Finding out why multiple entities with the same name are visible.
You have to tell Get- and SetSecurityInfo the object type, you can’t make it guess
It needs to know which provider to give it to.
Funding the Egghead store shopping spree took a little extra legwork
Just ask the boss.
Writing a helper class for generating a particular category of C callback wrappers around C++ methods
Another exercise in C++ template programming.
Thread pool threads are like preschool: Leave things the way you found them
Your mother always told you to clean up behind yourself.
Why does Windows even have Interlocked functions when we have std::atomic?
Well, you have to start somewhere.
Removing the MAX_PATH restriction on paths applies only to paths
The individual file names still retain their existing limits.
Application compatibility for Windows 95 crashed a cash register
Exceeding all reasonable maximums.
Dubious security vulnerability: Tricking a program into running non-elevated
You can do anything, but still within the limits of your authority.
Why does C++ think my class is copy-constructible when it can’t be copy-constructed?
You said that you had a copy constructor, even though it can't be compiled.
Why do some Windows functions fail if I pass an unaligned Unicode string?
Well, if you don't align it, then you've already broken the rules.
Riffing on a typo in the name of the opera Turandot
On the dot.
How can I programmatically find the network path by which a folder has been shared?
There is no direct query. You'll have to infer it.
The symbolism of the magnifying glass is not universal
Just making things bigger?
Stating the obvious about debugging an invalid parameter error when freeing memory
Writing it down for posterity.
Using an oracle to see where your code is producing the wrong output
If there is a reference implementation, then use it as a check.
The case of creating new instances when you wanted to use the same one
C++ language backward compatibility makes legal what you had hoped wasn't.
How do I convert a WIC bitmap back to a GDI HBITMAP?
You can copy the bits into a DIB section.
What was origin of the code name Redpill for Windows 8 feature lockout?
Pretty obvious, actually.
Why does EnumProcessModules report no modules on a process that was created suspended?
There are no modules yet because you didn't give them a chance to load.
How can I detect if one of my helper processes is launching child processes?
You can ask a job object to keep track for you.
How can I create a window the size of the screen without it being treated as a fullscreen window?
You can declare that you aren't rude.
Silly parlor tricks: Promoting a 32-bit value to a 64-bit value when you don’t care about garbage in the upper bits
Inline assembly that doesn't do anything.
Why does Windows report my processor speed twice, with slightly different values?
One is calculated. The other is self-promotion.
Secret passages on Microsoft main campus, episode 3
Another covered passage between buildings.
What’s with the weird wReserved value at the start of the DECIMAL structure?
It's where the discriminant goes when the <CODE>DECIMAL</CODE> is put "inside" a <CODE>VARIANT</CODE>.
How do I force RunOnce commands to run in a specific order?
Run them in the desired order yourself.
If I mark my thread pool callback as long-running, does it still count toward the thread pool thread limit?
Yes, because it's still in the thread pool.
What is the developer set-up for developing Windows for multiple processor architectures?
You usually just pick one and count on your friends for the others.
Dubious security vulnerability: A program does not run correctly if you run it the wrong way, redux
Trying to make the system run the program automatically.
How can I wait for Clipboard History to recognize a clipboard change before I change it again?
Listen for the change event.
Why doesn’t Clipboard History capture rapid changes to clipboard contents?
Clipboard history operates asynchronously, so you are changing it before it can respond to the changes.
What were the MS-DOS programs that the moricons.dll icons were intended for?
Tallying them up.
What were the MS-DOS programs that Windows used the progman.exe stock icons for?
Mostly generic-looking icons.
What were the intended uses of those icons in moricons.dll?
Icons for old MS-DOS apps.
Using type aliasing to avoid the ODR problem with conditional compilation, part 2
Ensuring that you pick a side.
Using C++ type aliasing to avoid the ODR problem with conditional compilation, part 1
Still one definition, but two types.
Why does Windows have trouble finding my Win32 resource if it contains an accented character?
Disagreements over the fine print.
Protecting Windows users from Janet Jackson’s Rhythm Nation
Granting an exception to a system policy.
Why did Windows 7, for a few months, log on slower if you have a solid color background?
It's waiting for Godot and eventually gives up.
If we can have std::atomic<std::shared_ptr>, why not std::atomic<com_ptr>?
Controlling the reference count.
When I define a window class with no default cursor, what is the explanation for the cursors that appear in my client area?
You said you'd take care of it, but you didn't.
What resource ID should I give my application’s main icon?
Applying what we know about how Explorer finds the "first" icon in a file.
Microspeak: top of mind
Things I'm thinking about.
The ongoing story of seconds on the taskbar
The cost of ticking.
The case of the feature flag that didn’t stay on long enough, part 2
Leaving everything the way you found it.
The case of the feature flag that didn’t stay on long enough, part 1
Understanding scope and order of destruction.
Using the classical model for linking to provide unit test overrides
Overriding a LIB with an OBJ for fun and profit.
There was a lot of imagined dropping tablets in swimming pools
The archetypical example of needing a replacement computer.
Dubious security vulnerability: Once I have tricked the user into running a malicious shortcut, I can install malware
Yes, that's sort of the point.
The case of the UI thread that hung in a kernel call
I did tell you not to do that.
Function overloading is more flexible (and more convenient) than template function specialization
You can change more things in an overload.
Why can’t I use SEC_LARGE_PAGES with a file-based file mapping?
No paging, no crying.
The Goldilocks zone of software stability
Not too new, not too old.
On priority inversion in the use of a spinlock to ensure atomic access to a shared_ptr
Priority inversion may be rare, but correctness doesn't care about rarity.
Adding delays to our task sequencer, part 3
Waiting more cheaply.
Adding delays to our task sequencer, part 2
Waiting the right amount of time.
Adding delays to our task sequencer, part 1
Not so fast there.
The return of Building 7
Pranksters lose one of their longtime inside jokes.
If one program blocks shutdown, then all programs block shutdown, revisited
No take-backs.
The 2025/2026 Seattle Symphony subscription season at a glance
The pocket reference guide for 2025/2026.
Fixing exception safety in our task_sequencer
Exception safety, the forgotten requirement.
On launching a dialog when a specific combo box item is selected
Changing selections is not a good time to launch a dialog box.
Why does INVALID_HANDLE_VALUE cast through a LONG_PTR first?
LONG_PTR first?
To ensure that the proper sign extension happens.
We’ll fly you to Atlanta, Texas, and getting to your hotel in Atlanta, Georgia is your problem
Reading the fine print.
A note on the USB-to-PS/2 mouse adapter that came with Microsoft mouse devices
It's a purely mechanical adapter that relies on smarts in the mouse itself.
On how different Windows ABIs choose how to pass 32-bit values in 64-bit registers
Surveying the options and looking for commonalities.
The case of the critical section that let multiple threads enter a block of code
It had one job.
What could cause a memory corruption bug to disappear in safe mode?
A simplified execution environment means fewer things that you can stumble over.
You can’t simulate keyboard input with PostMessage, revisited
If it didn't go through the input system, it only looks like input as much as the app allows itself to be fooled.
Why didn’t Windows 95 setup use a miniature version of Windows 95 as its fallback GUI?
Avoiding an interim GUI environment.
Dubious security vulnerability: A program does not run correctly if you run it the wrong way
So what did you expect?
The case of COM failing to pump messages in a single-threaded COM apartment
A customer encountered a hang caused by COM not pumping messages while waiting for a cross-thread operation to complete. They were using the class for serializing asynchronous operations on a UI thread they created to handle accessibility callbacks. The hang stack looked like this: We see that we have a UI thread (notice the at the bottom of the stack), yet COM decided to block without pumping messages ( instead of (). Is this a bug in the task sequencer? Let's look at the stack more closely. A message arrived via , and that then queued a task into the task sequencer. The saw that the task sequencer had...
Making sure that a DLL loads only from your application directory
You can ask for it as an option, but think about what you're actually protecting against.
What are the thread safety requirements of HSTRING and BSTR?
They do not have thread affinity.
What an insightful observation, you get to wear “the hat”
Maybe not so insightful.
How do I destroy an ABI pointer that I extracted from a C++/WinRT object?
You can clean it up the ABI way, whatever that is.
To some people, time zones are just a fancy way of sounding important, episode 2
Words have meaning.
How can I choose a different C++ constructor at runtime?
Make somebody else do it, and then use copy elision.
I tried to subscribe to a C++/WinRT event, but my callback was never called
Check how you registered your event handler.
Microspeak: Respin
Spin it up again, baby.
Lexically scoped functions accessing parent locals: The display
Using a well-known location instead of copying frame pointers.
C++/WinRT implementation inheritance: Notes on winrt::implements, part 8
Comparing the options.
C++/WinRT implementation inheritance: Notes on winrt::implements, part 7
Inheritance without involving <CODE>winrt::implements</CODE> at all.
C++/WinRT implementation inheritance: Notes on winrt::implements, part 6
Using CRTP to delegate the method.
C++/WinRT implementation inheritance: Notes on winrt::implements, part 5
When the base class isn't self-contained.
C++/WinRT implementation inheritance: Notes on winrt::implements, part 4
Simple inheritance of a self-contained <CODE>implements</CODE>.
C++/WinRT implementation inheritance: Notes on winrt::implements, part 3
Discovering the legal inheritance structures for <CODE>winrt::<WBR>implements</CODE>.
C++/WinRT implementation inheritance: Notes on winrt::implements, part 2
Untangling <CODE>unwrap_<WBR>implements_t</CODE>.
C++/WinRT implementation inheritance: Notes on winrt::implements, part 1
A closer look at the parameters to the <CODE>implements</CODE> template.
Your statement is now available, just two hidden flyouts and five clicks away
Beware of the leopard.
API design note: Beware of adding an “Other” enum value
What are you going to do when you add a new kind?
Investigating an argument-dependent lookup issue and working around it
Picking apart the language specification.
A sample implementation of the weak reference pattern for COM callbacks
A forwarder through a weak reference.
Async-Async revisited: What about cancellation?
Even the cancellation is async.
Did the Windows 95 setup team forget that MS-DOS can do graphics?
Oh look what you just made there.
How does Explorer find the “first” icon in a file
It enumerates them and takes the first one, so this is really a question about enumeration.
Using alternate locales to get more interesting case mapping than the C
Looking for something better.
The default C locale is not a very interesting one
It barely understands anything.
On exactly when XAML bindings are evaluated if an element is not yet loaded
It depends on which abstraction you prefer.
The original name for Flexible Single Master Operations in Active Directory
Not that kind of F-word.
On trying to log an exception as it leaves your scope
You can't watch it from an object on the outside.
Creating a generic insertion iterator, part 2
Satisfying the iterator requirements, perhaps with a little cheating.
Creating a generic insertion iterator, part 1
We provide the boilerplate; you provide the smarts.
How do I create an inserter iterator that does unhinted insertion into an associative container like std::map?
Curiously missing from the standard library.
My electric toothbrush was acting up, so I tried to reboot it
It didn't help.
A pattern for obtaining a single value while holding a lock
The immediately-invoked lambda that returns a value.
A brief and incomplete comparison of memory corruption detection tools
A short overview, definitely incomplete.
Memory corruption from outside the process looks like space aliens
The write isn't visible to your process, just the effect of the write.
Be mindful of temporal terms in documents: What is the reference point in time?
What is your implied point in time for the reference?
Why is there a bulge on my bicycle tire when I inflate it?
Get the order of operations right.
Why doesn’t the Windows blue screen of death prominently identify the company that created the driver that crashed?
Because the driver that crashed may not be the one at fault.
Reminder: When a C++ object fails to construct, the destructor does not run
If you need to run after a failed construction, you have to put it in a base class or member variable.
The case of the crash when trying to erase an element from a std::set
Another kind of fiasco.
In a C++ class template specialization, how can I call the unspecialized version of a method?
You can't talk about things that might exist, so instead talk about things that do.
How does GetUserDefaultGeoName choose between ISO 3166-1 and UN M.49 codes?
Clarifying the behavior.
Microspeak: The walk-on topic
Just walk on in with your topic.
A simplified overview of ways to add or update elements in a std::map
And using it to find missing opportunities.
Why does inadvertently passing a std::string instead of a char const* to a variadic function crash on x86-32 but not x86-64?
Looking at the calling convention and the small string optimization.
Inside STL: Waiting for a std::atomic<std::shared_ptr<T>> to change, part 2
Digging into the libstdc++ implementation.
Inside STL: Waiting for a std::atomic<std::shared_ptr<T>> to change, part 1
Waiting on a single pointer, but checking for two.
Gesellschaft zur Stärkung der Verben: The German Society for the Irregularization of Verbs
Stand strong and proud.
Emergency power resets on Lenovo, HP, Dell, and Acer laptops
Looking for the magic button.
How can I tell whether a change to a control was due to the user or due to my program?
You know when it was done by your program because you did it.
Forcing an ERROR_KEY_DELETED error when trying to open HKEY_CURRENT_USER\Software
Just an exercise to show that it can be done, even though it's highly unlikely to occur in practice.
Could I be getting ERROR_KEY_DELETED for HKEY_CURRENT_USER\Software when the user logs off?
Probably not, but there are some edge cases.
How is it possible to get ERROR_KEY_DELETED when I’m creating a key?
The key that got deleted is not the one you are trying to create.
2024 year-end link clearance
The cycle completes.
Making sure the Microsoft Visual C++ compiler chooses the right source encoding
Making sure the file and settings are set correctly.
How various git diff viewers represent file encoding changes in pull requests
The invisible UTF-8 BOM, and sometimes invisible encoding changes.
In C++, failure to meet the requirements does not always mean that you fail if you don’t meet the requirements
Combining SFINAE/requires, standard layout, and overload resolution.
Why are Win32 resources strings bundled at all? And why bundles of 16?
Balancing multiple performance factors.
How can I check if two GUIDs are equal when they are provided as strings?
A customer asked if there was a helper function in the system that accepted two strings and reported whether the s they represent are equal. This is a tricky question, because you first have to decide what "represent" means. There are many ways of representing a as a string. It could be just 32 case-insensitive hexadecimal digits. Or maybe there are internal hyphens to separate the groups. And the whole thing might be enclosed in braces or parentheses. External and interior whitespace might be allowed. Trailing garbage might be accepted (and ignored). And then there's the special format {0x00000000,0x0000,0x00...
A design flaw in the Windows 3D Pipes screen saver pointed out by a customer
Time-wasting.
A common proposed solution to certain categories of IFNDR: Getting the linker to verify identical functions
You could do it, but it could cramp your style.
How do I register a file type for a scripting language so that users get a warning when they run an untrusted script?
Use the FTA_AlwaysUnsafe edit flag.
Inside STL: The atomic shared_ptr
There's a lock hiding inside the pointer.
Is there a way to split the git history of a file or combine the histories of two files without a merge commit?
Studying how git recovers history.
Microspeak terms that didn’t take hold: airspace, synthetics, and AOI
Sometimes they don't stick.
Why do we have header files <pshpackN.h> and <poppack.h> instead of just issuing the pragma directly?
Because the pragma may not work everywhere.
Converting to a derived class from the future: How to cast from a base class to an incomplete derived class?
Deferring the definition until the class is complete.
API naming principles for conditional operations: On, When, and If
Describing when a condition is tested.
What is the CONTINUE_IF_FAILED equivalent of RETURN_IF_FAILED?
Be careful how you write it, or better: Don't write it at all.
It rather involved being on the other side of this airtight hatchway: Disabling anti-malware scanning
If you have already infiltrated the process, then you can disable things from the inside.
Learning to read C++ compiler errors: Failing to create a shared_ptr
Understanding what you asked the compiler to do, and why it couldn't comply.
Learning to read C++ compiler errors: Nonsensical errors from a function declaration
Look closely at what the error message is complaining about.
Won’t waiting for multiple threads one at a time introduce a severe performance issue?
It depends on how long you plan on waiting.
Why does my DLL reference count go up by one every time I create and exit a thread?
If you use a wrapper, you need to follow the wrapper's rules.
Tricks from product support: We’re not smart enough to debug the problem, can you help us?
It's not you, it's me.
News flash: Desire for loud cars correlates with psychopathy and sadism
More research into loud vehicles.
An analogy about register preservation rules in calling conventions
And tying it back to unwind codes.
Assessing the attack complexity of a race condition security vulnerability
It's not just how small the race window is, but how easy it is to hit the window.
Why does my program successfully take foreground only when running under the debugger?
That's a special exception to the normal foreground rules.
Checking whether a URI refers to a Web site root
Let somebody else do the parsing.
Microspeak: Real estate and Airspace
Space on the screen and negotiating control over it.
How can I know when a window has processed a message that I posted to it?
Best would be to have it tell you.
In C++, how can I make a default parameter be the this pointer of the caller?, revisited
Expanding on the previous pattern.
How can I detect which menu my item was invoked from?
Just give them all different IDs. But this might itself by an XY problem.
How do I determine whether Explorer is showing or hiding file extensions?
You can ask, but maybe you're asking the wrong question.
A wrinkle in how Windows 95 setup bootstrapped its initial GUI step
Getting access to the common controls that don't exist until Windows 95.
The operations for reading and writing single elements for C++ standard library maps
Breaking down the options.
How do I put a non-copyable, non-movable, non-constructible object into a std::optional?
Taking advantage of the conversion operator.
Solving the puzzle of trying to put an object into a std::optional
How do I set a value? Let me count the ways.
The puzzle of trying to put an object into a std::optional
The C++ standard library template type has one of two states. It could be empty (not contain anything), or it could contain a . Suppose you start with an empty . How do you put a into it? One of my colleagues tried to do it in what seemed to be the most natural way: Use the assignment operator. Unfortunately, the assignment failed to compile: I asked for the rest of the error message, because the details will explain what the compiler tried to do (and why it couldn't). It's long, but we'll walk through it. The compiler is showing its work. It's showing you all the possible overloaded assignment opera...
Why did Windows 95 setup use three operating systems?
Simplifying the problem to an earlier problem.
Debugger breakpoints are usually implemented by patching the in-memory copy of the code
The code in memory may not match what the debugger shows you if the debugger is itself is doing the changing.
The case of a program that crashed on its first instruction
Didn't even make it out of the gate.
Why do I observe reads from a memory-mapped file when writing large blocks?
The CPU doesn't see the entire write at once.
How do I declare an operator overload for my Windows Runtime class?
That's not something expressible in the Windows Runtime.
What’s the difference between Display size and Screen size in the Windows 95 display control panel?
No meaningful difference, though others have created a difference.
On the limits of time travel in the face of undefined behavior in C
C imposes some constraints, but the principle is mostly still there.
On locale-aware substring matching, either case-sensitive or case-insensitive
It's surprisingly complicated, but fortunately, somebody has done it for you.
What has case distinction but is neither uppercase nor lowercase?
It has one foot in each world but belongs to neither.
I have enabled “take ownership” permission, but I still cannot obtain write access
Taking ownership is only one part of gaining write access.
Reverse-engineering what a “short” section is
The long and short of it all.
How useful is the hint passed to the std::unordered_… collections?
Only a little, or sometimes not at all.
How can I explicitly specialize a templated C++ constructor, follow-up notes
You can use a maker function, but that doesn't let you escape the problem.
It rather involved being on the other side of the airtight hatchway: Defeating ASLR after you’ve gained RCE via ROP
If you defeat ASLR, then you can defeat ASLR.
How do I create a Windows Runtime IRandomAccessStream around a bunch of bytes or a classic COM IStream?
Another wrapper function.
Did Windows 95 shrink the default font size of windowed MS-DOS apps?
The effect was that it shrunk, but only sometimes.
Why does adding WS_MINIMIZEBOX change how my window behaves when the user presses Win+D?
It minimizes your window if it can.
Evaluating tail call elimination in the face of return address protection, part 2
Rewriting the activation frame.
Evaluating tail call elimination in the face of return address protection, part 1
Reusing the activation frame.
Effects of classic return address tricks on hardware-assisted return address protection
Return address manipulations that are possibly even more impermissible than they already were.
A quick introduction to return address protection technologies
Detecting attempts to manipulate the return address.
On naming things: The tension between naming something for what it is, what it does, or how it is used
You are guaranteed to make someone upset.
How can I explicitly specialize a templated C++ constructor?
Looking for a C++ tag type for representing another type.
A correction to the awaitable lock for C++ PPL tasks
Over-scoped lock.
If threads are created without a message queue, why can I post to them immediately upon creation?
Check who is doing the posting.
Microspeak: Run to ground
Come to a resolution.
A popular but wrong way to convert a string to uppercase or lowercase
Converting character by character isn't good enough any more.
How does the linker decide whether to call WinMain or wWinMain?
If you don't tell it, it will try to figure it out.
How can I detect whether the user is running as an elevated administrator (as opposed to a natural administrator)?
You can ask for the elevation type.
A function for creating an absolute security descriptor from a self-relative one
Just wrap it up.
Misunderstanding the “Prevent access to registry editing tools” policy
It prevents access to the tools, but not to the registry itself.
Pulling a single item from a C++ parameter pack by its index, remarks
Why such a complicated way to pull the type from the pack?
The case of the crash when destructing a std::map
Who is corrupting the map?
If you’re going to specify the LVS_SORTASCENDING or LVS_SORTDESCENDING style, you had better be telling the truth
Because the listview control uses it to optimize searching.
Another example of the Windows Runtime interop pattern: Using the UserConsentVerifier from a Win32 program
Following the standard pattern.
The UserConsentVerifier confirms that the user is there, but it doesn’t protect any data
Is that really you?
Going beyond the empty set: Embracing the power of other empty things
Just because there's nothing in it doesn't mean it's not valid.
How can I check that all the changes in a git branch have been cherry-picked or rebased into its upstream branch?
You can pretend to merge it and see if anything happens.
My window has the WS_EX_NOACTIVATE extended style, but it got activated anyway
Well, at least it wasn't activated by a click.
More on the mysterious [default_interface] attribute in Windows Runtime classes
Forcing you to make a choice.
It rather involved being on the other side of this airtight hatchway: Posting completions to somebody else’s I/O completion port
If you have gained access to it, then that was the problem.
Some notes on Win32 carets
Assorted notes and musings.
The case of the fail-fast crashes coming from the power management system
Understanding why it decided to fail fast.
How can I tell whether two programs will share drive letter mappings?
You can compare the authentication IDs.
The case of the string being copied from a mysterious pointer to invalid memory, revisited
Reflections on an older topic.
Does the Resource Compiler have a separate preprocessor or doesn’t it?
It did, but now it doesn't.
GitHub trick to find the commit that deleted a file
Ask for the history of the file.
The case of the image that came out horribly slanted: Negative stride
It's all topsy-turvy.
The case of the image that came out horribly slanted: Taking the pitch into account
Getting the pieces to line up.
The case of the image that came out horribly slanted: Diagnosis
Imperfect pitch.
Why did Windows 95 use blue screen error messages instead of hard error messages?
You may not able to get there from here.
The CoInitializeSecurity function demands an absolute security descriptor
Even though you usually have a self-relative one in hand.
In the Windows kernel, what is a LUID, and what makes it loo-ey?
It's a locally-unique ID, for a specific definition of "local".
How is the Windows.Foundation.Uri.Domain property different from Host?
It's an educated guess.
On the strange status of wchar_t in classic MIDL
From the era before <CODE>wchar_t</CODE> was a standard type.
The Microsoft/IBM joint development was built on mutual respect, wait, is respect the right word?
Maybe it's some other word.
Thoughts on finding the essential elements of a set
Another binary search, but searching a different way.
What if I need to wait for more than MAXIMUM_WAIT_OBJECTS threads?
Studying your options, and the consequences of breaking things up.
The role of the activation factory in the Windows Runtime
The activation factory represents the class itself.
What does ERROR_KEY_DELETED mean?
You now have a handle to a key that doesn't exist, and there's nothing you can do with it.
Another tribute to Microsoft history hiding in Building 41
Logo touches.
Constructing nodes of a hand-made linked list, how hard can it be?
Trying to force copy elision.
The case of the missing ordinal 380
Untangling the error message and developing a theory.
Instead of putting a hash in the Portable Executable timestamp field, why not create a separate field for the hash?
That would defeat the purpose.
Temporarily dropping a lock: The anti-lock pattern
It's not to prevent locking, but rather to counteract a lock.
A look back at one of the (many) projects code-named Highlander
The showdown that almost repeated.
Embracing the power of the empty set in API design (and applying this principle to selectors and filters)
You got plenty of nothing.
What does it even mean to Close a Windows Runtime asynchronous operation or action?
That's the end of the road.
Why do I get E_ACCESSDENIED when trying to access my brokered Windows Runtime object?COM is double-checking the trust level.
COM is double-checking the trust level.
How do I know when the user has finished interacting with the AccountsSettingsPane?
You can use the version that runs an asynchronous operation.
It rather involved being on the other side of the airtight hatchway: Disabling a security feature as an administrator
At least they don't beat around the bush.
What are the dire consequences of registering a RunOnce command from my RunOnce command?
The circle of life, or a perpetual motion machine.
The difference between undefined behavior and ill-formed C++ programs
They are two kinds of undefined-ness, one for runtime and one for compile-time.
What’s the difference between DataPackageView.GetUriAsync and DataPackageView.GetWebLinkAsync ?
Just improving on an ambiguous name.
How to compress out interior padding in a std::pair and why you don’t want to
Context-sensitive layout means you get a different structure each time you use it.
There is no mystery over who wrote the Blue Screen of Death, despite what some may want you to believe
No real contradictions in anybody's story.
Why don’t Windows Imaging Component pixel format GUIDs continue their nice pattern?
Patterns are predictable, which is not always a good thing.
What can I do if IMlangConvertCharset is unable to convert from code page 28591 directly to UTF-8?
You can do the conversion in two steps using things you already have.
In my Visual Studio project, I set my Conformance mode to permissive, but it’s still not permissive
Digging into what the compiler sees.
API naming principle: If there is no direct object, then the direct object is the source object
If you don't know what it operates on or produces, then it operates on or produces itself.
Unquoted service paths: The new frontier in script kiddie security vulnerability reports
Usually not exploitable, but the script kiddies don't know that.
Organizing the five creation dispositions of the CreateFile function
Six possibilities, but only five useful ones.
Creating an already-completed asynchronous activity in C++/WinRT, part 9
Cheating the delegates.
Creating an already-completed asynchronous activity in C++/WinRT, part 8
Generalizing the pattern.
Creating an already-completed asynchronous activity in C++/WinRT, part 7
Implementing the contract directly.
Creating an already-completed asynchronous activity in C++/WinRT, part 6
Let the conversion do the talking.
Creating an already-completed asynchronous activity in C++/WinRT, part 5
Trying to fail more correctly.
Creating an already-completed asynchronous activity in C++/WinRT, part 4
Failing is easy. Failing correctly is hard.
Creating an already-completed asynchronous activity in C++/WinRT, part 3
Generalizing to the four kinds of Windows Runtime asynchronous activities.
Creating an already-completed asynchronous activity in C++/WinRT, part 2
Making our function a coroutine.
Creating an already-completed asynchonous activity in C++/WinRT, part 1
The simplest version.
What’s the point of std::monostate ? You can’t do anything with it!
Not doing anything with it is exactly the point.
How do I produce a Windows Runtime asynchronous activity from C++/WinRT?
Somebody that deals with them natively.
How do I produce a Windows Runtime asynchronous activity from C#?
The AsyncInfo helper class converts Tasks to Windows Runtime asynchronous activities.
How do I produce a Windows Runtime asynchronous activity from C++/CX?
The Parallel Patterns Library has special support for C++/CX.
The history of Alt+number sequences, and why Alt+9731 sometimes gives you a heart and sometimes a snowman
Code pages and custom keyboard handling.
If I register the same shell extension as both a context menu extension and a drag/drop extension, how do I know which one the system is using?
Who forced you to register the same shell extension for both?
2024 mid-year link clearance
Emptying out the junk drawer.
Writing a remove_all_pointers type trait, part 2
Factoring out the type resolution to after the dangerous part.
Writing a remove_all_pointers type trait, part 1
Delaying the expansion to avoid infinite recursion.
Is there a built-in way in C++/WinRT to get the string name for a Windows Runtime enum?
No, and maybe you don't want to.
Microspeak: Fun fork
A place to party.
Finding a specific value in a sequence of integers that changes by at most 1
It's basically a discrete version of the intermediate value theorem.
The Windows Runtime winrt::hstring and the C++ std::wstring are inter-assignable
Just assign them over, no cermony necessary.
How to convert between different types of counted-string string types
Looking for constructors that take a character count.
On the sadness of treating counted strings as null-terminated strings
You're throwing away perfectly good data, there.
The time smart quotes prevented the entire Office division from committing code
Breaking your tools with your tools.
How can I view the list of symbols available in a library?
A tool hiding inside another tool.
Lock-free reference-counting a TLS slot using atomics, part 3
Keeping track of two things at once.
Lock-free reference-counting a TLS slot using atomics, part 2
Getting it is easy. Getting rid of it is hard.
Lock-free reference-counting a TLS slot using atomics, part 1
First, we do it with locks.
The origin story of the Windows 3D Pipes screen saver
Looking for a place to show off.
How do I get the name of a SID, and what does it mean when the conversion fails?
Most places will do it for you, or at least try.
What’s the deal with std::type_identity?
When you want to use a type without participating in type deduction.
Can INI files be Unicode? Yes, they can, but it has to be your idea
It'll only be Unicode if it's already Unicode.
How 16-bit Windows cached INI files for performance
Taking advantage of co-operative multitasking.
Why does GlobalLock max out at 255 locks?
Because that's how many bits were available for reporting the lock count.
More on harmful overuse of std::move
Could we expand copy elision to cover the harmful cases?
A graphical depiction of the steps in building a C++ executable, with XAML and packaging
Fleshing out the diagram.
A graphical depiction of the steps in building a C++ executable, enhanced for classic Win32
Adding in Microsoft-specific tools.
A graphical depiction of the steps in building a C++ executable, basics
A high-level overview.
How can I force a DLL to register itself if it won’t respond to regsvr32?
You can't force something that isn't there.
Is there any difference between StringFromIID and StringFromCLSID?
Not really.
Setting the contents of a Windows Runtime Vector from C++/WinRT in one call
The one-stop shop for updating a Windows Runtime Vector.
Creating a prepopulated Windows Runtime Vector from C++/WinRT without going through an explicit std::vector
Creating the vector inline.
If you have to create a Windows Runtime Vector from C++/WinRT, do it as late as possible
Stay with the <CODE>std::vector</CODE> until you really need the Window Runtime Vector.
A blurry photo of the legendary USB Cart of Death
And some details about that infamous on-stage bluescreen.
If you know what interface you want, just pass it directly to CoCreateInstance
Avoiding a second round trip.
Why can’t I find the injected name of a templated class’s templated base class?
The compiler needs help finding it because it's not findable at the time the template is parsed.
Pulling a single item from a C++ parameter pack by its index
Combining a few tools to make a new tool.
Building the most efficient device selector query that selects no devices
Looking for the most efficient way of rejecting everything.
The confidential coffee maker was not the only source of shenanigans at the IBM Boca office
The culture (and weather) clash continues.
Before you try to change something, make sure you can change nothing
Nobody touch anything.
An informal comparison of the three major implementations of std::string
Pros and cons.
Asking for a DispatcherQueue from a GUI thread you created
Grafting a DispatcherQueue onto an existing thread.
Awaiting a set of handles with a timeout, part 7: Just doing it one at a time
A simpler version with its own quirks.
Awaiting a set of handles with a timeout, part 6: Capturing the handles efficiently
SFINAE'ing the case of a random-access(ish) iterator.
Awaiting a set of handles with a timeout, part 5: Generalizing the awaiter
Fitting into existing patterns.
Awaiting a set of handles with a timeout, part 4: Building our own awaiter
To stop relying on unspecified behavior.
Awaiting a set of handles with a timeout, part 3: Going beyond two
Generalizing what we learned last time.
Awaiting a set of handles with a timeout, part 2: Continuing with two
Giving it another try.
Awaiting a set of handles with a timeout, part 1: Starting with two
Let's see by seeing if we can do it with just two.
Awaiting a set of handles in C++/WinRT
It's easier thank you think.
Adding state to the update notification pattern, part 8
Comparing the two algorithms.
Adding state to the update notification pattern, part 7
Going free-threaded.
Adding state to the update notification pattern, part 6
Using a change counter with coalescing.
Adding state to the update notification pattern, part 5
Using a change counter.
Adding state to the update notification pattern, part 4
What if the UI thread isn't there to save you?
Adding state to the update notification pattern, part 3
Abandoning the background work if we know that it is pointless.
Adding state to the update notification pattern, part 2
First attempt to try to fix the race condition.
Adding state to the update notification pattern, part 1
Where each notification depends on some state information.
In search of the Ballmer Peak, and other results from SIGBOVIK 2024
Continuing studies in silliness.
Dubious security vulnerability: Program allows its output to be exfiltrated
Once the output is generated, the program can't control where it goes.
What were the tax consequences of letting Windows 95 team members keep a piece of software as long as they tested it?
It basically falls under the <I>de minimis</I> rule.
The case of the string being copied from a mysterious pointer to invalid memory
Using AppVerifier to deduce the heap allocation history.
Why do STANDARD_RIGHTS_READ , STANDARD_RIGHTS_WRITE , and STANDARD_RIGHTS_EXECUTE have the same values?
Don't they mean different things?
How can I find out which process has locked me out of the clipboard?
You can ask for the clipboard opener.
If I enumerate all the processes and add up all the GetGuiResources, why doesn’t it match the GR_GLOBAL value?
There are some things that aren't charged to processes.
How does the classic Win32 ListView handle incremental searching?
Combining prefix search with repeated search, to accommodate multiple styles.
The case of the exception that a catch (…) didn’t catch
Reconstructing a false history.
It rather involved being on the other side of this airtight hatchway: System corruption caused by an administrator
If your goal was to corrupt the system, you sure are doing it the hard way.
Windows debugger trick: Breaking when a specific debugger message is printed
A different kind of conditional breakpoint.
The history of computing, as told by the hallways of Microsoft Building 41
A walk through history, in the form of wall textures.
Subroutine calls in the ancient world, before computers had stacks or heaps
A lot of computing got done even before we had stacks and heaps.
How can I tell C++ that I want to discard a nodiscard value?
A variety of tricks, with different degrees of readability and legality.
I called CreateEnvironmentBlock with a process’s token, but I didn’t get that process’s environment
That's not what the <CODE>CreateEnvironmentBlock</CODE> function does.
Some choices for encrypting data so that it can be decrypted only by the same user or computer
There's your classic, and there's some newfangled stuff.
Dubious security vulnerability: Manual operations can cause a program to hang
You did this to yourself.
Why isn’t C++ using my default parameter to deduce a template type?
Trying to have it both ways.
Why does my thread get a broken string as its initial parameter?
It got converted too late.
Using the DisplayInformation class from a desktop Win32 application, part 2
Completing the prerequisites.
Using the DisplayInformation class from a desktop Win32 application, part 1
A little interop music.
How well does C++/WinRT com_ptr support class template argument deduction (CTAD)?
It doesn't even try, and probably doesn't want you to do it.
How well does wil com_ptr support class template argument deduction (CTAD)?
Falling into a hole in the C++ language, not filled in until C++20.
How well does WRL ComPtr support class template argument deduction (CTAD)?
It tries too hard and accidentally breaks CTAD.
How well does ATL CComPtr support class template argument deduction (CTAD)?
It actually works right out of the box.
How well does MFC IPTR/CIP support class template argument deduction (CTAD)?
Not very well, thanks to requiring the interface ID to be specified explicitly.
How well does _com_ptr_t support class template argument deduction (CTAD)?
Not very well, thanks to storing the pointer and IID pair in a helper type.
Class template argument deduction (CTAD) and C++ COM wrappers: Initial explorations
How well do these libraries support a feature that likely didn't exist at the time they were written?
The 2024/2025 Seattle Symphony subscription season at a glance
The pocket reference guide for 2024/2025.
How can I force a copy of a C++ value?
Forcing a copy with a minimum of typing.
In C++/WinRT, you shouldn’t destroy an object while you’re co_awaiting it
A generalization of the ground rules of programming.
How do I make an expression non-movable? What’s the opposite of std::move?
You can turn it into a const thing so it's no longer movable, in a conventional sense.
In domain\user syntax, you can often use the period as an abbreviation for “this computer”
A bit of a typing saver, particularly with complex machine names.
Is shadowing a member variable from a base class a bad thing? Maybe, but maybe not.
It depends on the order in which things occurred.
C++/WinRT performance trap: Switching to Windows Runtime too soon
Stay in the devirtualized world until you are forced to leave.
If a parameter isn’t used, what should I pass?
It doesn't matter what you pass, but if you have to ask, then just pass zero.
On the whole idea of giving away a reference to yourself at destruction
Hey, at least it's possible.
Mitigating attacks based on knowing the length of a Windows Hello PIN
Balancing convenience against security, and how you can tune the knobs toward more security.
A C# LINQ one-liner to check if exactly one of a set of conditions is met
Maybe not the most efficient, but it's easy to write.
Gotcha: Be careful how you shut down your dispatcher queues
The dispatcher queue thread isn't useful after it has shut down, so don't try anything.
Gotcha: Don’t forget to shut down your dispatcher queues
Keep that dispatcher queue controller around, or you'll never be able to clean up.
Once your object reaches final_release, you are committed to destructing it (eventually)
Don't try to resurrect it.
Microspeak: Closing out, duping out
Making work items no longer appear on a query.
Why can’t I trigger a manual blue screen crash by injecting the magic key sequence?
It has to come from the physical keyboard, because that's the code that detects the magic key sequence.
If you’re just going to sit there doing nothing, at least do nothing correctly
How to be inert.
Registered command lines are just command lines, not a programming language
If you want a programming language, you know where to find one.
Functions that return the size of a required buffer generally return upper bounds, not tight bounds
An over-estimate is better than an under-estimate.
It rather involved being on the other side of this airtight hatchway: Attacking a domain administrator from the local administrator
If you pwn the machine, then you pwn everyone on the machine.
How can I get the Windows Runtime HttpClient to display a basic authentication prompt?
You need to give it some help finding the right window.
On the virtues of the trailing comma
A more uniform appearance comes with its own benefits beyond aesthetics.
How do I suppress the error box that appears when a LoadLibrary fails?
They don't appear often, but they do appear occasionally.
Why doesn’t my program get fancy drag/drop effects in high contrast mode with CLSID_DragDropHelper ?
You have to upgrade your manifest.
On using milliseconds as a measure of network latency
There's a limit to how much technology can improve.
How can I close a thread pool and cancel all work that had been queued to it?
You can put them in a group.
The case of the invalid parameter error from MeasureOverride
Chasing it back to its origin.
Using virtual memory placeholders to allocate contiguous address space for multiple purposes
Can you hold this for a second?
How can I add an environment variable to a process launched via ShellExecuteEx or IContextMenu?
Hooking into the way the Windows shell launches processes.
Smoothing over the differences (and defects) in the various implementations of IMemoryBuffer
Stick to the part that nobody messes up.
A comparison of various implementations of the Windows Runtime IMemoryBuffer
Every unhappy class is unhappy in its own way.
How can I expose a pre-existing block of memory as a Windows Runtime object without copying the data?
Assembling all the pieces.
How can I give away a COM reference just before my object destructs?
You have to do it before committing to destruction.
The dangerous implementations of the IMemoryBufferReference.Closed event
Mistakenly handing out COM references that don't work.
The useless IMemoryBufferReference.Closed event
It tells you that you have already lost.
Accessing a block of memory represented by a Windows Runtime IMemoryBuffer
Through the currency known as an IMemoryBufferReference.
The case of the fail-fast trying to log a caught exception
What is being thrown and why can't we log it?
Implementing two-phase initialization with ATL
ATL looks like it supports two-phase initialization, but it doesn't.
Getting a strong reference from the this pointer too soon
Giving out strong references to an object before you can guarantee that it will work.
What is a hard error, and what makes it harder than an easy error?
A throwback to the early days of 16-bit Windows.
C++/WinRT gotcha: Not all exceptions derive from hresult_error
There are also C++ standard exceptions, particularly <CODE>std::bad_alloc</CODE>.
In C++/WinRT, how can I await multiple coroutines and capture the results?, part 3
Dealing with awaitables that return <CODE>void</CODE>, and questioning our life choices.
In C++/WinRT, how can I await multiple coroutines and capture the results?, part 2
Wrapping the results and returning them in a tuple.
In C++/WinRT, how can I await multiple coroutines and capture the results?, part 1
Using a custom awaiter to suppress the <CODE>GetResults()</CODE>.
After I accidentally denied access to everyone, how do I get access back?
Congratulations, you locked your keys in the car.
How do I prevent my C++/WinRT implementation class from participating in COM aggregation?
Looking for a clue.
The case of the vector with an impossibly large size
Play threading games, win threading prizes.
How can I specify icons for my app to use on the Start menu in high contrast mode?
Put them in your manifest.
Why doesn’t my code compile when I change a shared_ptr<T>(p) to an equivalent make_shared<T>(p)?
It depends on who is doing the parameter conversion.
It rather involved being on the other side of this airtight hatchway: Attacking another program by modifying its memory
If you assume the existence of a vulnerability, you can use that vulnerability to attack something.
How do I prevent my ATL class from participating in COM aggregation? DECLARE_NOT_AGGREGATABLE didn’t work
That marker applies only to creation via the class factory.
2023 year-end link clearance
Ringing out another year.
How to allocate address space with a custom alignment or in a custom address region
Some new powers to guide the allocation.
On calling AfxConnectionAdvise with bAddRef set to FALSE
Playing fast and loose, and eventually you get burnt.
What does it mean when the compiler says that it can’t convert something to itself?
Why is it even thinking about a conversion?
Don’t keep state in your XAML item templates; put the state in the items
Beware of temporary alliances.
That time the Word team sent presents to the children of WordPerfect’s executive vice president
No, it wasn't creepy.
If I don’t have any items, what error should my IFolderView::Items method return?
It shouldn't return an error at all.
How do I get access to the wParam and lParam of the WM_QUERYENDSESSION method from my MFC message handler?
Don't be afraid to see how the macros are built.
It rather involved being on the other side of this airtight hatchway: Spoofing another program
You already had the power to do it yourself.
Microspeak: Locked and loaded
Armed and ready, with the suggestion that no further changes will be needed (or accepted).
In 2023, the Gävle Goat faces a new threat to its survival
It's bock.
If the RegisterClass function takes ownership of the custom background brush, why is it leaking?
It takes ownership only on success.
How do I specify an optional string parameter to a Windows Runtime method?
Strings are sort of reference but sort of values.
How do I specify an optional parameter to a Windows Runtime method?
There is no way to express explicit optionality, but there are implicit ways.
How can I work around the absence of default parameters in the Windows Runtime?
You can fake it with overloads.
What happens if I define one environment variable in terms of the value of another environment variable?
Only certain types of dependencies are supported.
The mysterious second parameter to the x86 ENTER instruction
For an ABI that probably nobody uses.
A simpler version of the task sequencer that doesn’t promise fairness
Just let a kernel object control the access.
In C++, how can I make a default parameter be the this pointer of the caller?
Again, you can't, but you can fake it.
In C++, how can I make a member function default parameter depend on this?
You can't, but you can fake it.
What was the code name for 64-bit Windows?
Sundown, which was a hidden jab at the competition.
What is a static chain pointer in the context of calling convention ABI?
Buried in the System V Application Binary Interface.
Why does the Windows Portable Executable (PE) format have both an import section and input directory?
They seem to be the same thing. Do we need both?
Why does the Windows Portable Executable (PE) format have separate tables for import names and import addresses?, part 2
Keeping read-only data separate from read-write data.
Why does the Windows Portable Executable (PE) format have separate tables for import names and import addresses?, part 1
Even though their lifetimes don't overlap, you sometimes need to go back in time.
A reported vulnerability about getting paid apps for free is really about paying for free apps
Try shopping around.
In Windows 3.1 and Windows 95, what is a “grabber”?
It grabbed your MS-DOS screen and put it into a window.
On harmful overuse of std::move
Initial excitement leads to overuse.
On the need to keep most event sources alive if you want them to raise events
You can't receive a notification from something that doesn't exist.
How can I convert a Windows Runtime SoftwareBitmap to a WIC bitmap?
The reverse of <CODE>ISoftwareBitmapNativeFactory::<WBR>CreateFromWICBitmap</CODE>.
Microspeak revisited: Line of sight
A fancy way of saying unimpeded network connectivity.
If you’re going to crash on an unhandled exception, you may as well do it sooner rather than later
Avoiding the problem discovered by the case of the invalid argument exception from a method that takes no arguments.
The theory behind the IHttpFilter interface
Layering features on top of each other.
What happened to the custom exception description I threw from a C++/WinRT IAsyncAction?
The description is just a courtesy and is not part of the API contract.
Why does calling a coroutine allocate a lot of stack space even though the coroutine frame is on the heap?
Heap elision optimization kicks in, and doesn't kick out.
Starting on the other side of this airtight hatchway: Running a program that leaks memory
There are a lot of things you can do to consume memory.
What is the difference between UuidToString, StringFromCLSID, StringFromIID, and StringFromGUID2?
Different ways of stringizing a GUID.
The case of the invalid argument exception from a method that takes no arguments
Where did the invalid argument come from?
A clarification on the multithreading constraints of the EncryptMessage function
Reading a sentence in the context of the whole paragraph.
How can I get information about media playing on the system, and optionally control their playback?
Going to the global system media transport controls world.
“Stop sharing this folder” is not the same as “Never share this folder”
It stops sharing the folder, but that doesn't prevent you from starting it again.
Why doesn’t reduction by modulo work for floating point values?
Working out why it works for integers and seeing what goes wrong.
Why does unsafe multithreaded use of an std::unordered_map crash more often than unsafe multithreaded use of a std::map ?
It's all in the implementation details.
How come my custom exception message is lost when it is thrown from a IAsyncAction^?
Things that survive in the C++ world and things that are lost when you cross the ABI.
More notes on use of the DS_CONTROL style
Styles that have to go in, and styles that have to come out. (And styles that you can choose.)
What is the thread reaper?
Should you fear the thread reaper?
What are the dire consequences of not removing all the properties that were set via SetProp?
Not so much any more, but it could be a sign that you forgot something.
How to support a COM interface conditionally in WRL
Customizing the QueryInterface and GetIids methods.
How to support a COM interface conditionally in C++/WinRT
Prevent <CODE>winrt::implements</CODE> from responding to it or reporting it.
The format of icon resources, revisited
Filling in some gaps.
Why is there a hash of a weak password in the Windows cryptographic libraries?
They're part of an internal self-test.
How do I add a non-copyable, non-movable object to a std::map or std::unordered_map?
Fancy emplacement.
On the failed unrealized promise of RegOverridePredefKey
An early attempt to sandbox the registry for a process.
What’s the difference between setting a page’s protection to PAGE_NOACCESS and freeing it?
Nobody can access it, but it's still there.
How can I check if I’m on a DispatcherQueue’s thread if I can’t call HasThreadAccess?
Looking at the tools you have available.
Microspeak: The As-Appropriate (AA) interviewer
So, how are things going so far?
API design principle: Reading a property or adding an event handler should not alter observable behavior
Don't punish people for looking.
On detecting improper use of std::enable_shared_from_this
Playing around with the standard library.
I created an overloaded operator for my C++/WinRT class, but it’s not working
Take a closer look at what you are overloading.
Why does IFileDialog still show non-filesystem folders when I pass FOS_FORCEFILESYSTEM ?
Because you need to pass through them to get there.
It rather required being on the other side of this airtight hatchway: Knowing the domain administrator password
If you give away the password, well, that's sort of on you.
Is there any performance advantage to marking a page read-only if I had no intention of writing to it anyway?
The CPU already figured it out.
A very belated improvement to the filtering of the Browse for Folder dialog so it shows only drive letters
The case of the very short UNC.
How can I get WideCharToMultiByte to convert strings encoded in UTF-16BE?
You first have to get it into a format the WideCharToMultiByte accepts.
On the confusing names for the Windows service SID types
Too much abbreviation.
A complaint about Links the Cat, the Office assistant
Do all cats do that?
How do I manually update a remote tracking branch, say, to undo a fetch?
Updating refs to point to whatever you like.
Template meta-programming: Avoiding saying a type before it is complete
Deferring use until after the class is defined.
C++/WinRT gotcha: get_strong() will produce a broken strong reference if destruction has already begun
A strong reference to nothing.
The dangers of releasing the last strong reference from within its own callback
Deadlocking with yourself.
Why is kernel32.dll running in user mode and not kernel mode, like its name implies?
It's just a name, and it comes from the days before user-mode/kernel-mode separation.
GetQueueStatus and the queue state
There's stuff going on that's hiding behind the innocuous-looking name.
When I try to call an exported function, the target crashes when it tries to call any Windows function
Using what you know about how functions are imported to construct a theory that matches the evidence.
How does Explorer calculate the “Date” of a file?
Mapping the generic concept to specific file types.
Why does my C++/WinRT project get unresolved externals for constructors?
You forgot to include the namespace header file, didn't you.
Why did the 16-bit _lopen and _lcreat function return -1 on failure instead of 0?
Trying to look like somebody else.
When looking to free up disk space, don’t forget your symbol file caches
They go all over the place.
How can I prevent myself from using a parameter after I’ve extracted all value from it?
You can shadow it with something useless.
I accidentally performed an operation on INVALID_HANDLE_VALUE , and it worked: What just happened?
Coincidentally valid, but not what you think.
How do I perform a case-insensitive comparison of two strings in the Deseret script?
It sort of depends on why you're comparing them.
The odd cadence of narrative engineering design documents
Following the rubric off a cliff.
Any sufficiently advanced uninstaller is indistinguishable from malware
The common pattern of trying to delete yourself.
On transferring or copying ABI pointers between smart pointers
Keep track of who owns the reference.
A freestanding JavaScript function that uses this is easily mistaken for a constructor
Because that's what constructors look like.
Detecting whether a tree-like data structure contains a cycle
Combining two things we already know.
When documentation cautions that something may not happen, that suggests that it normally does happen
Reading between the lines.
Just for fun: What happens when you shift a register by more than the register size?
A comparative study of processor architectures.
How do I find out more about the fail-fast exception that occurs when an exception in a PPL task goes unobserved?
Digging into the internals.
Diagnosing a crash when trying to call ReadFile via language interop
Checking the signatures and inferring what could have gone wrong.
How can I programmatically obtain the value of the “Make text bigger” slider?
The text scale factor property.
The popularity of DOS/4GW made Windows 95 game compatibility a little easier, but with higher stakes
A popular path to protected mode.
Just for fun: Which processors prefer sign-extended loads, and which prefer zero-extended loads?
Another pointless chart.
On writing loops in continuation-passing style, part 4
Equivalents in C# and JavaScript.
On writing loops in PPL and continuation-passing style, part 3
Explicit shared state.
On writing loops in PPL and continuation-passing style, part 2
Recursion comes back.
On writing loops in PPL and continuation-passing style, part 1
Keeping track of what to do next.
Inside STL: The different types of shared pointer control blocks
Well, some of them, at least.
Phantom and indulgent shared pointers
The phantom controls something yet holds nothing. The indulgent holds something but controls nothing.
What it means when you convert between different shared_ptrs
Changing the pointer while controlling the same object.
Inside STL: The shared_ptr constructor and enable_shared_from_this
Working together through a secret signal.
Inside STL: The shared_ptr constructor vs make_shared
Where to hide the control block.
Inside STL: Smart pointers
Simple pointers or more complicated pointers.
Inside STL: The array
It's just an array.
Inside STL: The deque, implementation
An array of (pointers to) arrays.
Inside STL: The deque, design
An array of (pointers to) arrays.
Inside STL: The unordered_map, unordered_set, unordered_multimap, and unordered_multiset
A hash table.
Inside STL: The map, set, multimap, and multiset
A red-black tree.
Inside STL: The lists
Your traditional singly- or doubly-linked list.
Inside STL: The string
An allocation, with a twist.
Inside STL: The vector
A contiguous memory block, reallocated as necessary.
Inside STL: The pair and the compressed pair
Two fields in one object, how hard can it be?
Misinterpreting the misleadingly-named STATUS_STACK_BUFFER_OVERRUN
The subcode tells you why we stopped executing, and it's rarely because of a stack buffer overflow.
How to split off an older copy of a file while preserving git line history
Variation on a theme.
Perfect forwarding forwards objects, not braced things that are trying to become objects
Before you can forward something, it needs to be a something.
On the various ways of creating Windows Runtime delegates in C++/WinRT and C++/CX
Comparing and contrasting.
Before you try to do something, make sure you can do nothing
If you can't do nothing, then don't expect to be able to do something.
Why does IAsyncAction or IAsyncOperation.GetResults() produce a E_ILLEGAL_METHOD_CALL exception?
You're asking too soon.
How to clone a Windows Runtime map in the face of possible concurrent modification, part 3
Doing it one more time, for C++/CX.
How to clone a Windows Runtime map in the face of possible concurrent modification, part 2
Applying what we learned about vectors.
How to clone a Windows Runtime map in the face of possible concurrent modification, part 1
Applying what we learned about vectors.
How to clone a Windows Runtime vector in the face of possible concurrent modification, part 4
Translating to C++/CX and dealing with some quirks of that language.
Cloning a Windows Runtime vector in the face of possible concurrent modification, denial of service?
Can you get sent into an infinite loop?
How to clone a Windows Runtime vector in the face of possible concurrent modification, part 3
Dealing with the pesky <CODE>std::vector<bool></CODE>.
How to clone a Windows Runtime vector in the face of possible concurrent modification, part 2
Trying to make a generic solution.
How to clone a Windows Runtime vector in the face of possible concurrent modification, part 1
Backing off and retrying, but the detection is the tricky part.
Why does the compiler complain about a missing constructor when I’m just resizing my std::vector to a smaller size?
The compiler doesn't know that you're shrinking.
How to wait for multiple C++ coroutines to complete before propagating failure, concluding remarks
The things that could go wrong before you even start.
How to wait for multiple C++ coroutines to complete before propagating failure, finding the awaiter
Making sure to wrap the right thing.
How to wait for multiple C++ coroutines to complete before propagating failure, wrapping the awaitable
Intercepting the exception on the front side.
How to wait for multiple C++ coroutines to complete before propagating failure, preallocating the coroutine frame
Avoiding dynamic memory allocation.
How to wait for multiple C++ coroutines to complete before propagating failure, memory allocation failure
There's no good way to report the failure, so we just have to give up.
How to wait for multiple C++ coroutines to complete before propagating failure, symmetric transfer
Avoiding stack build-up.
2023 mid-year link clearance
The tradition continues.
How to wait for multiple C++ coroutines to complete before propagating failure, custom promise
Taking things into our own hands.
How to wait for multiple C++ coroutines to complete before propagating failure, peeling away at a tuple
Iterating over a tuple recursively.
How to wait for multiple C++ coroutines to complete before propagating failure, false hope
Trying to iterate over a pack.
How to wait for multiple C++ coroutines to complete before propagating failure, unhelpful lambda
The usual trick doesn't work.
How to wait for multiple C++ coroutines to complete before propagating failure, initial plunge
Remembering the exception while finishing the other work.
What can go wrong if you release an SRWLock from a thread different from the one that acquired it?
It's not a supported scenario, so anything can happen.
How can I find out the last time a user logged on from C++?
The information is in the historically-named LANMAN APIs.
The case of the make_shared on a C++/WinRT type
Now you can't tell who's in charge.
Why is Windows using only even-numbered processors?
Spreading out the load over cores.
Why am I being told about a signed/unsigned comparison, and why only sometimes, and how can I fix it?
How the compiler back-end can influence warnings.
The case of the invalid handle despite being managed by an RAII type, part 2
Avoiding using an object after is has destructed, and maybe using a less-well-known corner of the C++ language.
The case of the invalid handle despite being managed by an RAII type
The handle remains valid for the object's lifetime, but what is the object's lifetime?
How expensive is it to create a Windows performance counter?
The cost depends on the performance counter.
SIDs are really just another a fancy way of creating unique IDs in a decentralized way
Keeping them from colliding with each other.
The move constructor that you have to declare, even though you don’t want anyone to actually call it
Forcing named return value optimization.
Reordering C++ template type parameters for usability purposes, and type deduction from the future
You want them to go first, but you also want to deduce them.
How can I register a program to auto-relaunch if it crashes or is terminated?, redux
You can get a little bit of the way there.
Pulling sleight of hand tricks in a security vulnerability report, episode 2
I see what you did there.
How can I make WiFi passwords per-user rather than per-system?
A little-known system configuration setting.
It’s great that you provide operator overloads, but it’s also nice to have names
Avoiding the need to invoke the operator explicitly as a specialized template, among other things.
C++/WinRT event handlers that are lambdas with weak pointers to the parent class, part 3
Extending to <CODE>std::weak_ptr</CODE>.
C++/WinRT event handlers that are lambdas with weak pointers to the parent class, part 2
Working out the boilerplate.
C++/WinRT event handlers that are lambdas with weak pointers to the parent class, part 1
Assessing the state of affairs.
How do I change the directory Windows uses for user profiles? revisited
You can still do it, but it's not really supported.
On writing functions that accept any specialization of a C++ template type
There are the obvious arguments, the non-obvious arguments, and the invisible arguments.
Getting a strong reference from the this pointer too late
Once destruction begins, strong references mean nothing.
How can I trigger a recalc of the mouse cursor after I changed some of my internal application state?, follow-up
You still need to filter to your window, so you don't mess up another window on the same thread.
Don’t name your header file security.h either
You may be overriding an SDK header by mistake.
On creating (and using) a transforming iterator
It lets you change the thing being iterated over, on the fly.
Speeding up the insertion of a sorted (or mostly-sorted) key list into a std::map or other ordered associative container
Provide a hint for the location of the next item.
On catching exceptions in PPL tasks
You also have to catch the exception when it comes out the end of the task chain.
What is the opposite of LVM_SORTITEMS?
How can you unring the bell?
How do I free the pointers returned by functions like GetTokenInformation?
They are all pointers back into the main memory block.
It appears that I’ve never made a complete visit to the Pacific Northwest
If the marketing department is to be believed.
Summary of the duck-typing requirements of C++ COM wrappers
Wrapping up and comparing.
What are the duck-typing requirements of C++/WinRT com_ptr?
The experiments conclude.
What are the duck-typing requirements of wil com_ptr?
The experiments continue.
What are the duck-typing requirements of WRL ComPtr?
Another round of experimentation.
What are the duck-typing requirements of ATL CComPtr?
Looking for the minimum requirements.
What are the duck-typing requirements of MFC IPTR?
Seeing what goes wrong and trying to fix it.
What are the duck-typing requirements of _com_ptr_t?
As long as you fulfill the contract, based on method names.
The case of the crash in a C++/WinRT coroutine: Unpeeling the onion
Digging deeper and deeper.
Why does XAML complain that none of the overloads of winrt::to_hstring could be used?
Look at what you are converting from and converting to.
What can I do if I don’t want my file version number to be a sequence of four integers?
The format is enforced by the Windows file format, but you can present the information in a custom way.
Why does Task Manager disappear briefly when you switch it into or out of Always on top?
Ascending to another plane of existence.
How is it even possible to cheat on a musical performance practical exam?
Nature finds a way.
A quick note about WRL’s ChainInterfaces template class
For interfaces which extend each other.
On the finer points of cancelling timers and wait objects in Windows thread pool
Assorted little details.
What’s up with this new memory_order_consume memory order?
A weaker variation of acquire.
One way to defer work when a re-entrant call is detected
Tying a string on your finger, as a reminder to yourself.
A code comment noting the steps to take when a 256th enum field is added
A note for my future self.
Why is std::hardware_destructive_interference_size a compile-time constant instead of a run-time value?
The compiler is already making compile-time assumptions about the processor; you just don't realize it.
Protecting a broker from a failing delegate
Catching them in a different way.
Protecting a broker from a failing event handler
Gotta catch them all.
The case of the unhandled exception in a brokered Windows Runtime component
Digging into the event dispatch code.
No, it is not a security vulnerability that there is no certificate of appreciation for reporting a bug
It wasn't even a bug report.
How can I find the invalid class when C++/WinRT tells me that the class may not be final?
It's in the error details.
How can I convert a WIC bitmap to a Windows Runtime SoftwareBitmap? part 4: Handing it over
Just take the whole thing.
How can I convert a WIC bitmap to a Windows Runtime SoftwareBitmap? part 3: Filling the SoftwareBitmap directly
Avoiding the intermediate buffer.
How can I convert a WIC bitmap to a Windows Runtime SoftwareBitmap? part 2: Via a buffer
Passing raw pixels across.
How can I convert a WIC bitmap to a Windows Runtime SoftwareBitmap? part 1: Via an encoded stream
We'll start with the hard way, but it gets easier.
Why is there a large gap between some of the Windows system metrics indices?
An artifact of the internal implementation.
The case of the PasswordVault.Add call that the customer thinks was hung
But was it really hung? Or did it just look that way.
An ignored exception can be misinterpreted as a hang, particularly in coroutines
I mean, execution seems to have stopped.
How do I modify the contents of a boxed Windows Runtime value?
Once it's in the box, you can't change it.
What is the maximum size of a process environment block?
There's no hard-coded limit in Windows, but maybe somebody else has a limit.
C++17 creates a practical use of the backward array index operator
Possibly more than just a curiosity.
What is this [uuid(…)] in front of my C++ class declaration?
It's an old nonstandard syntax that you should try to move away from.
If you want to watch games on your tractor, please use your own iPad
Not an approved use of the embedded system.
How can I box a std::optional into a C++/WinRT IInspectable?
There's a handy conversion for that, but you have to know where to look.
The WM_GETDLGCODE message is a query message and should not modify state
Wait until you actually get the message.
How can I try to escape the disease-ridden hot-tubs known as the TEMP and Downloads directories?
You can ask that dependent DLLs be loaded from the System32 directory.
Using the contents of a file to define an MSBuild property
A little trick that maybe should be better known.
Adventures in application compatibility: The case of the jump into the middle of an instruction from nowhere
Another rogue patcher.
How unique must the uIdSubclass parameter be when I call SetWindowSubclass?
Each one identifies an instance of the subclass for the window.
Why am I getting a weird error about promise_type when I try to write a coroutine? part 2
Are you even writing a coroutine?
Why does the usage of the initial registers of a Win32 process depend on whether it is a 32-bit or 64-bit process?
Well, I mean, it's a different processor.
On the proper care and feeding of the enigmatic GetDistanceOfClosestLanguageInList function
Thinking about how this could be used.
Exploiting C++/WinRT CRTP: Property and event declarations
They don't have to be methods; they just have to look like methods.
Mind your C++/WinRT namespaces
What you say changes meaning depending on where you are.
How can I create a git feature branch that can merge into multiple other branches?
Just work in your patch branch.
Did Vienna ever exist or was it just misinformation?
It could be neither.
The 2023/2024 Seattle Symphony subscription season at a glance
The pocket reference guide for 2023/2024.
What is the expression language used by the Resource Compiler for non-preprocessor expressions?
Oddly different for a different audience.
When should I use CS_GLOBALCLASS?
When you want to be summoned from anywhere.
From a Windows app, how can I check whether there is an app installed that implements a particular URI scheme?, part 2
Alternatives that work for unpackaged apps.
From a Windows app, how can I check whether there is an app installed that implements a particular URI scheme?
Additional function to let you see what is available.
Microspeak: Baseball card
A one-page summary, and this time we mean it.
I can create a read-only page, but why not a write-only page?
At the end of the day, it comes down to processor support.
Enumerating Windows clipboard history in PowerShell
Doing Windows Runtime things from PowerShell.
Enumerating Windows clipboard history in C++/WinRT and C#
Exploring the clipboard history API.
If you want to sort a Windows Runtime collection, you may first want to capture it into something a bit easier to manipulate
Moving everything into the same universe.
Once you give away the farm, you can’t take it back: Recovering from a rogue administrator
Who knows what happened to it while you weren't looking.
The unintentionally-expanding scope of the SEM_NOGPFAULTERRORBOX flag
Other suppressions caught in its net.
Understanding a mysterious RPC_E_WRONGTHREAD exception when we’re on the right thread
Things can go wrong in ways you may not have realized.
Why am I getting an unhandled exception from my C++ function that catches all exceptions?
Yes, you caught an exception. But that's not the one that went unhandled.
Avoiding the redundancy of adding the object files to both the primary project and its unit test
Adding another level of indirection.
Microspeak: Light reading (ironic)
Just a fun diversion.
The case of the mysterious "out of bounds" error from CreateUri and memmove
Unfolding some COMDATs.
What happens if you co_await a std::future, and why is it a bad idea?
Just waiting for something to finish.
What does it mean when my cross-thread COM call fails with RPC_E_SYS_CALL_FAILED ?
Look for an unresponsive recipient.
What are the potentially-erroneous results if you don’t pass NULL as the lpNumberOfBytesRead when issuing overlapped I/O?
It's to avoid a self-inflicted race condition.
Why are the Windows chassis hardware button hotkeys so strange?
Operating within the constraints of the system.
Adventures in application compatibility: The case of the display control panel crash on exit
When you get a 64-bit pointer, you probably should remember all 64 of the bits.
The case of the RPC_E_DISCONNECTED error thrown from await_resume
You can keep trying, but the result won't change.
A more direct and mistake-free way of creating a process in a job object
A new attribute for creating a process directly in a job object.
How can I get the original target of a shortcut without applying any 32-bit adjustments?
Disable the fancy tracking.
The frustration of finding a suitable time to hold a meeting when the participants are evenly spaced around the globe
Somebody has to suffer, but we try to make sure it's not the same person each time.
It rather involved being on the other side of this airtight hatchway: Reading the user’s saved passwords
Only the user can read their own saved passwords, so you must already have gained total control over the user.
Inside C++/WinRT: Coroutine completions: Cancellation propagation
Giving up.
Hyperlinking to Hutchison Whampoa Limited is still forbidden
Didn't make you look.
Inside C++/WinRT: Coroutine completions: Avoiding reentrant completion
Resuming the coroutine directly, rather than consuming yet more stack.
Inside C++/WinRT: Coroutine completion handlers: Disconnection
When the other end hangs up without even saying good-bye.
Inside C++/WinRT: Apartment switching: Error reporting
If you can't get back to where you started, who you gonna call?
Inside C++/WinRT: Apartment switching: COM without COM
Also known as Nano-COM.
Inside C++/WinRT: Apartment switching: Unwinding the stack
Reducing stack usage.
Inside C++/WinRT: Apartment switching: Bypassing the context callback
Reducing stack usage.
Inside C++/WinRT: Apartment switching: Unblocking the outgoing thread
Avoiding the problem of the synchronous apartment-changing callback: Let the outgoing thread do whatever it wants to do next.
Inside C++/WinRT: Apartment switching: The basic idea
Getting back to where you started.
Inside C++/WinRT: Coroutine completions: The oversimplified version
Resuming the coroutine when the asynchronous work completes.
How can I call a method on a derived class from a base class, say, to get a strong reference to the containing object?
A variety of patterns are available.
Windows Runtime asynchronous operations can fail in two different ways, so make sure you get them both
Fail me now or fail me later.
It rather involved being on the other side of this airtight hatchway: Attacking a user by modifying that user’s files
You're just attacking yourself.
A trio of dubious denial-of-service security vulnerability reports which are just style points piled on top of nothing
You could have accomplished the same thing with a garbage file.
Making C++ primitive types meaningfully movable when they have sentinel values
The value actually moves now.
Adventures in application compatibility: Querying for an internal interface
Reaching in and fiddling the internal knobs.
How should I interpret the various values of NLM_CONNECTIVITY?
Different levels of connectedness.
What does it mean when I get a mismatch from MSVC for _COROUTINE_ABI?
The two different kinds of coroutine interfaces shouldn't be mixed and matched.
It rather involved being on the other side of this airtight hatchway: Administrator attacking a domain account on the local system
You don't gain control over any other systems.
On leading underscores and names reserved by the C and C++ languages
The rules laid out.
Dubious security vulnerability: Granting access to SIDs that don’t exist yet
You can put anyone you like on your guest list, even if they don't exist.
How can I force a user to have a specific SID prefix, so that they go into a particular group?
The prefix doesn't define group membership.
Using perfect (and imperfect) forwarding to simplify C++ wrapper classes
Just call that other thing the same way you called this thing.
It rather involved being on the other side of this airtight hatchway: Gaining code execution from a Trojan horse
You already have code execution, so it's not surprising that you can gain code execution.
Opinionated notes on the Windows.Data.Json namespace
It's available if you need it, but there are some tricks and pitfalls, and you may very well have better options.
2022 year-end link clearance
Closing the book on another year.
When I create a waitable timer with a callback, do I have to wait alertably on that specific timer before the callback will run?
Any alertable wait will do.
How can I detect programmatically whether Windows is an N or KN version?
Don't check the version, just check the feature.
After importing a TLB, how do I convert from one type of _com_ptr_t to another?
Digging into the source code.
Why can’t I print when I boot Windows into audit mode?
It's not all there.
The worst-selling Microsoft software product of all time: OS/2 for the Mach 20
Count 'em on one hand.
The case of the recursively hung WM_DRAWCLIPBOARD message
Understanding why it's happening and how you can avoid it.
Is there a fixed virtual address that the system promises never to use for anything, so I can use it?
Everything is up for grabs.
Running some UI code on a timer at a higher priority than your usual timer messages, or without coalescing
You can build your own timer system.
Why doesn’t the BitLocker wizard let me save the BitLocker key on an encrypted drive?
Don't lock your keys in the car.
On the large number of ways of expressing Microsoft Visual C++ compiler versions
So many version numbers.
Why doesn’t Windows use the 64-bit virtual address space below 0x00000000`7ffe0000?
It does use it, although it doesn't look like it.
Inside C++/WinRT: IReference<T>
Reverse-engineering the usages from the code.
In C++/WinRT, how do I create or consume an IReference<T> that wraps a particular value?
Conversions to and from <CODE>IReference</CODE>.
Thank you for conference announcement, but it would help if you told me what your conference was about
There was an announcement of an all-day Microsoft-internal conference featuring a project I will call Project Enzyme. The announcement went like this: The Project Enzyme Forum is our flagship community conference that brings together engineers, project managers, data scientists, and designers from around the company to learn about Project Enzyme and get a first look at some of the exciting new improvements in the platform. Senior leaders will share their vision for Project Enyzme and how we can use it to create the next wave of cutting-edge products and experiences. Other senior leaders will participate in a ...
What does it mean when the compiler tells me that promise_type: is not a member of coroutine_traits<void>?
Applying your understanding of the coroutine transformation.
How can I do the opposite of compare_exchange and exchange if the value is different?
An exchange with itself has no effect on the value.
If you’re going to wrap a Windows Runtime event, you may as well let the wrapped event source manage the token
It keeps the original object in control.
Reminder: If you intend to use a C++/WinRT namespace, you must include that namespace’s header file
Various errors that can be traced back to breaking that one rule.
Trouble connecting to Web sites and services because of certificate errors? Check if you’re being held captive
There's a man in the middle.
Instead of a C++ template parlor trick, why not just add support based on whether the header file has already been included?
Header file inclusion order dependencies.
C++ template parlor tricks: Using a type before it is defined
You can talk about hypothetical things, hoping that a real thing shows up later.
Not even trying to cross an airtight hatchway: Calling a function in your own process by synthesizing a function pointer
You can already attack yourself in far more interesting ways.
I used FILE_FLAG_SEQUENTIAL_SCAN but it didn’t seem to speed up my sequential scanning
It triggers prefetching, but your usage pattern may mean that prefetch doesn't mean much.
Dubious security vulnerability: Reading the files in the WindowsApps folder
You already had access to those files, by virtue of the fact that they ran in the first place.
What kind of caller diagnostic information can I get from exceptions thrown by C++/WinRT and wil?, C++20 edition
The state of the art has moved forward slightly.
The case of the application that used thread local storage it never allocated
Of course it's there, isn't it? I mean, it's always been there.
How do I pass a raw pointer to a Windows Runtime function?
Raw pointers don't exist in the Windows Runtime, so you'll have to re-express it in terms of something that does.
How does JavaScript represent output parameters in the Windows Runtime?
It has to fake it.
Sometimes perfect forwarding can be too perfect: Lazy conversion is lazy
Lazy conversion is too lazy.
Microspeak: Breaking into jail
Just asking for trouble.
What kind of caller diagnostic information can I get from exceptions thrown by C++/WinRT and wil?
A survey of the current state of the art.
On Windows Runtime asynchronous operations with critical progress reports
Make the caller provide the progress handler up front.
How soon is too soon to report progress from a C++/WinRT coroutine that implements a Windows Runtime asynchronous operation with progress?
If a progress is sent to a forest but there's no one there to hear it.
Why won’t C++/WinRT let me co_await a CoreDispatcher or DispatcherQueue?
Making sure you meet the usual prerequisites.
It’s important to get the most difficult part out of the way by putting it in the title
It does much less harm there than in the body.
How does Windows decide whether your computer has limited or full Internet access?
Looking for special servers.
C++ constexpr parlor tricks: How can I obtain the length of a string at compile time?
The <CODE>constexpr</CODE>'ification of <CODE>strlen</CODE>.
If I issue multiple overlapped I/O requests against the same region of a file, will they execute in the order I issued them?
Overlapped I/O refers to temporal overlap, and that includes completion out of order.
On the dangers of giving a product feature the name “new”
It may be new today, but it won't be new tomorrow.
Why don’t Windows functions begin with a pointless MOV EDI,EDI instruction on x86-64?
Applying the hot-patch in a different way.
Why is there a system sound called Asterisk? What sound does an Asterisk make anyway?
It's to accompany the asterisk, back when we had an asterisk.
My niece is just here for the food
The important part of the trip.
In the debugger, how can I get from a projected type back to the C++/WinRT implementation?
Look behind you.
Why am I getting a RPC_E_WRONG_THREAD exception when I’m on the right thread?
It's the wrong thread from XAML's point of view.
How does the dialog manager calculate the average width of a character?
It's a simple formula, perhaps too simple.
A history of the fd_set, FD_SETSIZE, and how it relates to WinSock
The <CODE>fd_set</CODE> started out as just a bitmap.
What is a “Select Administrator”? Is that some special elite kind of administrator?
It's two different messages that combine in an interesting way.
How can I test my geolocation code on a system without a GPS?
You can use the Windows Device Portal to create a synthetic GPS.
Setting properties in C++/WinRT is done by a function call, but you need to call the function the right way
The new value is the function parameter.
Why am I seeing two WRITE requests at the same offset from a single call to WriteFile?
It started as one write, but turned into a lot of other things.
What can or should I do with the cursor handle returned by SetCursor?
You can put it back, but sometimes you need to make sure you do it before anybody else can see the change.
Why are many Windows user interface elements positioned at multiples of 4 or 8 pixels?
It depends on whose pixels you're talking about.
Why can’t I programmatically inspect the check boxes in the Security property sheet any more?
Abusing the <CODE>ISecurityInformation::<WBR>PropertySheetPageCallback</CODE> method.
What happens if my C++ exception handler itself raises an exception?
And comparing to the handling of structured exceptions.
Is it true that raising a structured exception from a structured exception handler terminates the process?
Untangling the myth.
Why is there a make_unique? Why not just overload the unique_ptr constructor?
You'll have to resolve the ambiguity, so you're still typing a lot.
Why is there a passwords.txt file on my system that’s filled with somebody else’s passwords?
It's part of an open-source password strength package.
How can I check the integrity level of my process?
A series of range checks.
The case of the memory corruption from a coroutine that already finished
The zombie coroutine.
How can I check whether the user’s network connection is roaming or metered?
The classic way and the Windows Runtime way.
One possible reason why your program crashes when submitted to the Microsoft Store, but it runs fine on your machine
Check your minimum requirements.
Clicking past the warning that you are about to cross the airtight hatchway: Vulnerable file type that you are warned about
Acknowledging the danger but complaining about it anyway.
On the overloading of the address-of operator & in smart pointer classes
Different patterns, which means you're never sure what you're going to get.
How can I perform a CopyFile, but also flush the file buffers before the destination handle is closed?
Your callback function can do things with the handle, even extend their lifetime.
The Import Address Table is now write-protected, and what that means for rogue patching
Making a potential attack vector less attractive.
The gotcha of the C++ temporaries that don’t destruct as eagerly as you thought
You have to look for the end of the full expression.
Starting on the other side of this airtight hatchway: Overwhelming the system
It'll take time for things to drain out.
Feel free to stop using IMultiLanguage2::DetectInputCodepage
You should have been keeping your eye on the code page all along.
Debugging coroutine handles: Looking for the source of a one-byte memory corruption
Applying what we know about coroutines.
I did that merge-as-cherry-pick thing, but my change still didn’t merge correctly
A case study of what goes wrong.
Why does COM express GUIDs in a mix of big-endian and little-endian? Why can’t it just pick a side and stick with it?
Oh, it does pick a side. It's just that some dashes are missing.
Microspeak: Break glass
Metaphorically breaking the glass in case of emergency.
What does the C++ error “A pointer to a bound function may only be used to call the function” mean?
You got all set to call a function but forgot to call it.
Why am I receiving SHCNE_UPDATEDIR notifications that my code never generates?
You did generate them, indirectly.
How can I get WRL to link my object into its activation factory?
More magic macros.
How can I trigger a recalc of the mouse cursor after I changed some of my internal application state?
Go through the standard process one more time.
Janet Jackson had the power to crash laptop computers, follow-up
Deeper speculation by others.
Why load fs:[0x18] into a register and then dereference that, instead of just going for fs:[n] directly?
Simplifying the compiler.
Serializing asynchronous operations in C++/WinRT, gotchas and final assembly
Cancellation and abandonment.
Serializing asynchronous operations in C++/WinRT
Making them run one after the other.
Creating a lazy-start C++/WinRT coroutine from an eager-start one, part 2
Keeping a turkey in suspense.
Creating a manual-start C++/WinRT coroutine from an eager-start one, part 1
Ready, wait for it.
Serializing asynchronous operations in C#
Making them run one after the other.
The case of the APC that never arrives
Or maybe it did?
How do I consume raw COM interfaces from a Windows Runtime metadata file?
There's a handy tool for generating raw COM interfaces.
It rather involved being on the other side of this airtight hatchway: Replacing a service binary
Looking for misconfigured services.
Commonly-supported Windows shortcuts for pasting without formatting
Variations on a paste theme.
Is there any meaningful way to compare two Time Travel Debugging positions?
They are basically in chronological order, subject to the uncertainty of multiprocessing.
The case of the recursively-acquired non-recursive lock, and how to avoid the unintentional reentrancy
Watch what you do when you hold a lock.
Why am I getting a null pointer crash when trying to call a method on my C++/WinRT object?
Requirements weren't met.
The x86-64 processor (aka amd64, x64): Whirlwind tour
Pretty much a 64-bit-ification of the i386.
The AArch64 processor (aka arm64), part 25: The ARM64EC ABI
Aligning with the x86-64 calling convention.
The AArch64 processor (aka arm64), part 24: Code walkthrough
Putting theory into practice.
The AArch64 processor (aka arm64), part 23: Common patterns
Learning to recognize various code generation patterns.
The AArch64 processor (aka arm64), part 22: Other kinds of classic prologues and epilogues
Taking shortcuts, or maybe adding steps.
The AArch64 processor (aka arm64), part 21: Classic function prologues and epilogues
Implementing the ABI.
The AArch64 processor (aka arm64), part 20: The classic calling convention
How parameters are passed.
The AArch64 processor (aka arm64), part 19: Miscellaneous instructions
Sweeping up the crumbs.
The AArch64 processor (aka arm64), part 18: Return address protection
Making it even harder to smash the return address.
The AArch64 processor (aka arm64), part 17: Manipulating flags
Trying to twiddle the knobs directly.
The AArch64 processor (aka arm64), part 16: Conditional execution
Making decisions.
Janet Jackson had the power to crash laptop computers
Not an artistic judgement. Just a technical one.
The AArch64 processor (aka arm64), part 15: Control transfer
We're going places.
The AArch64 processor (aka arm64), part 14: Barriers
Keeping things in the right order.
The AArch64 processor (aka arm64), part 13: Atomic access
Don't let someone else get a word in edgewise.
The AArch64 processor (aka arm64), part 12: Memory access and alignment
The load and store part of the load/store architecture.
The AArch64 processor (aka arm64), part 11: Loading addresses
Finding a needle in the haystack of the 64-bit address space.
The AArch64 processor (aka arm64), part 10: Loading constants
Getting them into a register.
The AArch64 processor (aka arm64), part 9: Sign and zero extension
Nothing new here, but old things being used in clever ways.
The AArch64 processor (aka arm64), part 8: Bit shifting and rotation
Sliding around.
The AArch64 processor (aka arm64), part 7: Bitfield manipulation
Peeking inside the words.
The AArch64 processor (aka arm64), part 6: Bitwise operations
And their very strange immediates.
The AArch64 processor (aka arm64), part 5: Multiplication and division
Arithmetic gets harder.
The AArch64 processor (aka arm64), part 4: Addition and subtraction
Starting with the basic arithmetic.
The AArch64 processor (aka arm64), part 3: Addressing modes
The ways of accessing memory.
The AArch64 processor (aka arm64), part 2: Extended register operations
The weird ways of transforming the value in a register.
The AArch64 processor (aka arm64), part 1: Introduction
Make it a double.
Yes, the 8086 wanted to be mechanically translatable from the 8080, but why not add the ability to indirect through AX, CX and DX?
So many addressing modes, so little space.
Using C++/WinRT’s final_release to control which thread destructs your object
Once it's yours, you can take it wherever you like.
Making sure that people use make_unique and make_shared to make your object
Using a secret signal in what is required to be a public constructor.
My class derives from std::enable_shared_from_this , but shared_from_this() doesn’t work
Various cases where your enabled <CODE>shared_<WBR>from_<WBR>this</cODE> doesn't work.
Microspeak: The one-pager
Rarely ever one page long.
C++ coroutine gotcha: Falling off the end of a function-level catch
You still have to return something, but today's compilers don't warn you.
Processing a ValueSet or PropertySet even in the face of possible mutation, part 4
Processing the result differently.
Processing a ValueSet or PropertySet even in the face of possible mutation, part 3
Applying and adapting the pattern.
Processing a ValueSet or PropertySet even in the face of possible mutation, part 2
The first one there has to stay there until the work is done.
Processing a ValueSet or PropertySet even in the face of possible mutation, part 1
Watching out for iterator invalidation.
How can I provide a Windows Runtime ValueSet or PropertySet while non-intrusively monitoring changes to it?
Use the right kind of observer.
Windows Runtime observable collections don’t mix well with multithreading
Concurrent observation and mutation is a bit of a mess.
How can I write a coroutine that produces a result but keeps on running?
Returning without returning.
The empty Windows Runtime string is not just a pretty face
It really is an empty string.
How to write like Raymond: Intentional typographical errors, part 2
I can take you there, but you'll have to fix one tiny typo. Let's see if you can do that.
The case of the constructor that was being ignored
Retracing the compiler's steps.
Under what conditions can I modify the memory that I received in the form a STGMEDIUM?
If you own it, then it's yours to do with as you wish.
2022 mid-year link clearance
Another accumulation of stuff.
How can I build a URL query string in the Windows Runtime?
Pretend you're submitting a form.
How can I parse URL query string in the Windows Runtime?
There's a query parser built in, but it's a little cantankerous.
Microspeak: Inside baseball
Specialized jargon comprehensible only to a select few.
Starting on the other side of the airtight hatchway: Attacking the batch file parser
Why stop at denial of service when you have remote code execution?
The case of the mysterious over-release from deep inside the marshaling infrastructure
The tedium of monitoring reference counts.
Writing a marshal-by-value marshaler, part 2
Maybe you don't need a copy on the other side.
Understanding the marshaling flags: The free-threaded marshaler
Keeping your eye on the reference count.
Writing a compound marshaler
On the nature of streams.
On the importance of managing the stream pointer when manipulating marshal data
Making sure things are ready for the person who comes after you.
Writing a marshal-by-value marshaler, part 1
Creating an identical object on the other side.
The skeleton marshaler that does default marshaling
Starting with a marshaler that has no special features.
An initial look at the mechanics of how COM marshaling is performed
Pretend you're an oracle.
What are the various usage patterns for manually-marshaled interfaces?
The outermost simple layer, and the more complex inner layer.
Adventures in application compatibility: The case of the PC-relative indirect jump that reads from nowhere
A little too much copy/pasta.
How do I retrieve an extremely large range of cells from Excel if the clipboard functions all time out?
Maybe you shouldn't be using the clipboard.
How can I wait more than 30 seconds for a delay-rendered clipboard format to become rendered?
Provide your own delay.
Is there a maximum size for Windows clipboard data? Because I’m getting null for something I know should be there
There is no pre-set maximum size, but that null might be coming from somewhere else.
How to write like Raymond: Contacting another team for the first time
Flattery will get you in the door.
An opinionated comparison of C++ frameworks for consuming and implementing Windows Runtime types
The three leading contenders.
Assessing a read-after free for security implications: The string comparison
Can you get elevation? What are you disclosing?
Converting between Windows FILETIME and Unix time_t without having to type the magic number 116444736000000000
It's not exactly a number that you can rattle off the top of your head.
The case of the COM reference that suddenly went bad in the middle of a coroutine
Is the coroutine really to blame?
The activeCodePage manifest element can be used for more than just setting UTF-8 as the active code page
AppLocale grows up.
On passing iterables of iterables in the Windows Runtime
Different projections help you out in different ways, some more than others.
Why do rescued stack traces often have instability at the start?
Trying to pick up the scent.
Rescuing a stack trace the lazy way on x86-64 (aka amd64) after the debugger gave up
Looking for a good frame to start from.
How can I get my FileSavePicker to open in the same folder that was picked by the FileOpenPicker or FolderPicker?
Make them all share the same settings identifier.
What is the CreateExplorerShellUnelevatedTask scheduled task?
To keep Explorer running unelevated.
How does Windows decide whether a newly-created window should use LTR or RTL layout?
Gathering the algorithmic details scattered throughout the documentation into one place.
Writing a sort comparison function, part 4: descending sort
Flipping the script.
Writing a sort comparison function, part 3: spaceships
Sprinkling some C++20 magic.
Writing a sort comparison function, part 2: avoid unnecessary expense
Avoid doing the work until needed.
Writing a sort comparison function, part 1: basics
Trying to avoid the pitfalls.
How can I synthesize a C++20 three-way comparison from two-way comparisons?
Multiple ways of synthesizing a comparison.
Should I pay attention to the warning that I’m std::move‘ing from a trivial type? Part 2
It's not about the journey. It's about the destination.
Should I pay attention to the warning that I’m std::move‘ing from a trivial type? Part 1
It's just informing you that what you're doing may not have the desired effect, depending on what your desired effect was.
On ways of finding out when a C++/WinRT IAsyncAction has run to completion
Just some noodling on ideas.
A brief summary of the various versions of the Security Descriptor Definition Language (SDDL)
Things come, and rarely go.
Why does my overridable Windows Runtime method turn into a protected method, and how can I work around it?
Just an odd rule, but it's there for a reason.
On awaiting a task with a timeout in C++/WinRT
Doing the same thing, just in another language.
On awaiting a task with a timeout in C#
Putting something together from pieces you already have.
Producing an empty Windows Runtime type in C++/WinRT
How to say that you don't have anything.
What are these SIDs of the form S-1-15-3-xxx?
They are app capability SIDs.
What are these SIDs of the form S-1-15-2-xxx?
They are app container SIDs.
The case of the failed exchange of the vtable slot
Another application compatibility case.
What’s up with std::piecewise_construct and std::forward_as_tuple?
When you need to pass two sets of variadic parameters, and to work around other extremely weird edge cases.
How do I decode a #pragma detect_mismatch error?
The linker tells you a bunch of stuff. Here's what it means.
Be careful with that thing, it’s a confidential coffee maker
Just keep it under wraps.
How can I force a WriteFile or ReadFile to complete synchronously or hang, in order to test something?
You can use a named pipe.
Trying to create a factory that remembers the parameters to pass to another method
Lost in a twisty maze of universal references.
How do I access and customize the IInspectable methods of a Windows Runtime class written in C++/WinRT?
Special access methods, but normal overrides.
Class template argument deduction may be the new hotness, but we’ll always have maker functions
It's all or nothing, and sometimes you don't have all.
The Applesoft Compiler (TASC): We have the source code, in a sense
The desperation of programming under tight memory constraints.
The x86 architecture is the weirdo, part 2
It does everything differently, because of course it does.
How can I co_await on a Windows Runtime async action or operation with a timeout?
You can combine it with a timeout.
How can I tell the WIL RETURN_IF_FAILED macro that some errors are ignorable?
You can create a custom filter using things you already know how to do.
A survey of how implementations of Windows Runtime events deal with errors
All happy event delegates are alike; each unhappy event delegate is unhappy in its own way.
Notes on BitLocker and the TPM and the pre-boot password or PIN
How to get BitLocker and the TPM to play friendly.
Now that computers have more than 4MB of memory, can we get seconds on the taskbar?
Letting the CPU go to sleep.
Please repeat yourself: The noexcept(noexcept(…)) idiom
Each time you say it, it means something different.
If I am getting a DllNotFoundException from Windows 10 N, how do I get the missing DLLs?
Enter the Media Feature Pack.
All Windows threadpool waits can now be handled by a single thread
Come in and join the thread, the water's fine.
Adventures in application compatibility: The case of the RAII type that failed to run its destructor
Breaking all the rules and getting away with it.
How are Windows Runtime GUIDs represented in JavaScript?
They're strings, in various formats.
The std::invoke function does more than invoke functions
Inspiring a new level of code obfuscation.
Should I translate my window class names?
Who's going to read it?
Why am I getting the error message “This is only for weak ref support” when I try to create a C++/WinRT weak reference?
Reverse-engineering the error message.
How to become a Senior Detective, according to Murderville
A little copy pasta will take you far.
Why are there separate Program Files and Program Files (x86) directories?
Why can't we just combine them?
Why is every other line of my file mysteriously changed to nonsense Chinese characters?
Decoding another type of mojibake.
The 2022/2023 Seattle Symphony subscription season at a glance
The pocket reference guide for 2022/2023.
Behind C++/WinRT: How does C++/WinRT get the list of implemented interfaces?
Doing some template metaprogramming reverse engineering.
Behind C++/WinRT: How does C++/WinRT decide which interfaces are implemented?
Finding the code that does the interface detection.
Why does C++/WinRT say that first_interface is not a member of winrt::impl::interface_list<>?
An empty list has no first element, but why is the list empty?
A hypothetical magical musical power: The one-piece wonder
You can play one thing well, but only one.
How do I un-ignore an Outlook email thread, and how does it work?
A peek under the covers.
Injected class names: The C++ feature you didn’t even realize that you were using
Simplifying the name of what you are.
Making our multiple-interface query more C++-like, part 2
Letting you specify which interfaces are required and which are optional.
Making our multiple-interface query more C++-like, part 1
Maybe we can write a nice wrapper.
Reducing chattiness by querying for multiple interfaces at once, part 2
You can just load them into the cache.
Reducing chattiness by querying for multiple interfaces at once, part 1
The multiple-query alternatives.
How expensive is PssCaptureSnapshot? How fast is it? How much memory does it consume?
Think of it as a copy-on-write copy, like the Volume Snapshot Service.
Optimizing code to darken a bitmap, part 5
Once more, with ARM feeling.
Optimizing code to darken a bitmap, part 4
Bringing out the big SIMD guns, for x86 at least.
Optimizing code to darken a bitmap, part 3
Jumpless conditionals via masking.
Optimizing code to darken a bitmap, part 2
Exploiting parallel arithmetic.
Optimizing code to darken a bitmap, part 1
Starting with the basics.
If the slim reader/writer lock (SRWLOCK) doesn’t remember who the shared lock owner is, does that mean it’s okay to acquire it recursively?
No, but you sort of knew that deep down.
Filtering out fake keyboards from the GetRawInputDeviceList function
Maybe look to see if it has any keys.
How can I detect whether the system has a keyboard attached? On the GetRawInputDeviceList function
You can enumerate the input devices and see if there's a keyboard.
How does Windows decide what instructions to provide for unlocking the PC?
It sniffs around at your hardware capabilities.
Zero-cost exceptions aren’t actually zero cost
Shifting the cost to the exceptional path.
How can I monitor changes to the reference count of a C++/WinRT object?
A little cookbook.
COM asynchronous interfaces, part 9: Asynchronous release, assembling a solution
Juggling the references in the right way.
COM asynchronous interfaces, part 8: Asynchronous release, the problems
If you don't need something any more, then you usually don't really care when it gets taken away.
COM asynchronous interfaces, part 7: Being called directly when the operation completes
Becoming part of the system.
COM asynchronous interfaces, part 6: Learning about completion without polling
You can peek at the handle hiding inside the synchronization interface.
COM asynchronous interfaces, part 5: The unreliable server
Trying not to hang when the server is hung.
COM asynchronous interfaces, part 4: Doing work while waiting for the asynchronous operation
Just checking in on how things are going.
COM asynchronous interfaces, part 3: Abandoning the operation after a timeout
Waiting a little while, but not forever.
COM asynchronous interfaces, part 2: Abandoning the operation
Simply losing interest.
COM asynchronous interfaces, part 1: The basic pattern
Letting things run on their own, and then coming back for the answer later.
Notes on COM aggregation: How do you implement tear-offs in an aggregated object?
Keeping the controlling unknown in the know.
Notes on COM aggregation: Obtaining a pointer to your aggregated partner without introducing a reference cycle
Putting your thumb on the scale.
How can I find out which processor architectures are supported via emulation by the current system?
Fortunately, there's a special function for that, or at least for enough of that to serve your needs.
The cats sitting on a fence in early builds of Windows 8
Something to look at when all is lost.
On finding the average of two unsigned integers without overflow
Another code golfing adventure.
The case of the stack overflow exception when the stack is nowhere near overflowing
There's a problem with the stack that prevents it from growing, so you could consider than an overflow.
A closer look at the stack guard page
It is there to detect stack growth, but only if the stack grows into it.
Gotcha: C++/WinRT weak_ref.get() doesn’t get the weak reference; it gets the strong reference
What traditionally goes by the name <CODE>lock()</CODE>.
How do I customize the color of the Windows blue screen?
It's hard-coded now, sorry.
Why does the Windows debugger engine show a bunch of hex digits after one of the DLL names?
It's trying to disambiguate name collisions.
How can I recognize whether two handles refer to the same underlying file?
Exploring several avenues, hoping one of them leads somewhere.
How can I recognize file systems that don’t support 64-bit unique file identifiers?
It's buried somewhere in the specification.
What are these weird internal Visual C++ runtime functions named NLG?
They are part of exception handling.
I deleted a file from Explorer, but it came back when I refreshed, and I get Access Denied if I try to delete it again
The file is circling the drain, but it's not gone yet.
The MainWindowHandle property is just a guess based on heuristics
If you really need to find your main window, you'll have to come up with something more determinstic.
Fixing the crash that seems to be on a std::move operation
Getting the order of evaluation to be what you want.
The mystery of the crash that seems to be on a std::move operation
But is that really what's happening?
The error code you get might not be the one you want
Some error codes are contractual, but most aren't.
How to write like Raymond: The typing-saver
One of my little catch phrases.
C# and C++ type aliases and their consequences
Just some idle thoughts, and what it means for debugging.
Resolving confusion over how to return from a C++ coroutine
You have a few options, but you have to stay with it.
The oracle always tells the truth, even when it is wrong: COM method calls with a user-defined type as a return value
What you ship becomes the truth.
Standing on the shoulders of giants: Let the compiler tell you what the ABI is
Consult the oracle.
Jumping into the middle of an instruction is not as strange as it sounds
It's just another trick for saving space.
How can I detect that a thread pool work item is taking too long?
Call in a watchdog.
How do I upgrade a 32-bit tick count to a 64-bit one?
Fortunately, there's a 64-bit one sitting nearby.
Filling in some gaps in the story of Space Cadet Pinball on 64-bit Windows
The story as I experienced it.
How do I prevent folder verbs intended for file system directories from showing up in my shell extension’s virtual folder’s context menu?
They shouldn't be there in the first place.
My Excel spreadsheet doesn’t scroll even though I can use the arrows to move around
Freeze, and put your hands up!
Speculation on the design decisions that led to the common ABI for C++ coroutines
Considering some alternatives.
2021 year-end link clearance
Another trip around the sun.
The case of the programs that were launched with impossible command line options
Death and resurrection, unsuccessfully.
The C++/CX String^ is not an object, even though it wears a hat
A strange beast that thing is.
You can’t copy code with memcpy; code is more complicated than that
There's more to code than just instructions.
A rejected attempt to inject pseudo-physics into Windows 8 toast notifications
Like a mischievous rubber band flung across the screen.
How do I add custom controls to the common file open or file save dialogs?
A survey of the history of customization, leading to the present.
The Thanksgiving to Christmas sales nationwide of the VIS could be tabulated in an unsigned char
One of the great duds of console gaming history.
It’s easy to get data into the GPU, but harder to get it out
The continuing evolution of graphics memory.
How do I programmatically reposition monitors in a multiple-monitor system?
The magic phrase is <CODE>DM_POSITION</CODE>.
You thought Windows drivers from 2006 were old, wait’ll you see the Intel drivers from 1968!
It's the same driver date hack, just even more extreme.
Why do I have to add one when setting a class background brush to a system color?
To make sure it's not null.
Why is the stack overflow exception raised before the stack has overflowed?
You need some stack to deal with the exception.
Why does the precise point at which I get a stack overflow exception change from run to run?
The system is trying to introduce some unpredictability.
What does “Do not launch, but debug my code when it launches” mean?
Don't launch my code when it launches? Does that even make sense?
Embarrassing product names created: Windows CE
You do all you can, but at the end of the day, it's not yours to control.
Dubious security vulnerability: Accessing information across accounts after changing email address
It's still you, just with a different online façade.
It’s okay to be contrary, but you need to be consistently contrary: Going against the ambient character set
Code different.
If you’re going to configure a header file, you have to do it before you include the header file
It sounds obvious, but you can be faked out.
Using CRTP to your advantage: Simplifying overloaded Windows Runtime method projections in C++/WinRT
As long as the wrapper can call it, you can implement it any way you like.
What happens when a hot air balloon lands in your yard?
Break out the bubbly.
It rather involved being on the other side of this airtight hatchway: Producing malicious data in a kernel driver
Sure, you can fool other people, but you can do far more than that already.
Compiler error message metaprogramming: Helping to find the conflicting macro definition
Shaping the code so a required diagnostic will be useful.
How can I produce a C-style array from a Windows Runtime asynchronous operation?
No good solutions, but some workarounds.
How do I receive ownership of a C-style array in a Windows Runtime component?
The implementation side of the role reversal.
How can I transfer ownership of a C-style array to a Windows Runtime component?
Survey the options and realize that the only choice is to go backward.
How can my C++/WinRT component pass a std::vector back to the caller?
Implementing the ReceiveArray pattern.
How did Windows 3.1’s virtual machine manager get the information to show in the text-mode Alt+Tab switcher?
Getting by with a little help from a friend.
The two products may be identical, but they are not the same
No price-matching for you.
I called AdjustTokenPrivileges, but I was still told that a necessary privilege was not held, redux
Did any privilege adjustment occur at all?
How do I pass an array of variable-sized PROPSHEETPAGE structures to PropertySheet?
It's "just" an array of variable-sized structures.
Appending additional payload to a PROPSHEETPAGE structure
Taking it along for the ride.
Every business process secretly wants to fail
At least, that's how it looks from the outside.
A reminder about the correct way of accessing and manipulating the position of icons on the desktop
There's an interface for that. Please use it.
Why is my C++/CX ref class forbidden from having public methods that are templates or mention, say, std::vector?
C++/CX overloads the class member access control keywords to control metadata generation.
What does the CompileAsWinRT Visual Studio project option mean?
And why it's badly-named.
The mental model for StartThreadpoolIo
It's internally managing a reference count.
Microspeak: Righteous
A colloqualism that has become a preferred adjective.
A practical use for GetHGlobalFromStream when sharing was never your intention
This may even have been its original purpose.
Another way of looking at C++ reverse iterators
It's the same thing, just going in the opposite direction, right?
I sort of knew that I’m a bad flute player, but I guess this proves it
The fault is in ourselves, after all.
The inside story of the outside investigation of SoftRAM 95
It had a plan, but didn't quite execute on it.
How am I supposed to create children of the Win32 tab control?
They look like children, but they're not.
If your domain name parser can’t handle internationalized domain names, then maybe that’s your parser’s problem
Don't blame someone else for letting strange domain names reach you.
Restoring support for pre-standardization coroutine free awaiters for even older code bases
Connecting the dots, and reaching back to an earlier time.
The case of the C++/WinRT cached factories that pointed into freed memory
Developing theories that match the evidence.
How can I prevent myself from accessing a lambda captured variable or a parameter after I’m done with it?
Name-hiding on purpose.
A capturing lambda can be a coroutine, but you have to save your captures while you still can
Save it all before it disappears.
The focus rectangle says, “I’m not orange. I’m just drawn that way.”
How does <CODE>DrawFocusRect</CODE> draw the focus rectangle?
Why do all this coroutine stuff if you can just use std::future?
Escape from PPL.
Giving a single object multiple COM identities, part 4
Simplifying the pattern.
Giving a single object multiple COM identities, part 3
Returning to the scene of the crime.
Giving a single object multiple COM identities, part 2
Trying to develop a slightly more efficient multi-headed snake.
Giving a single object multiple COM identities, part 1
Like a multi-headed snake.
A very brief introduction to patterns for implementing a COM object that hands out references to itself
We'll look at many choices, but focus on one.
Renaming a file is a multi-step process, only one of which is changing the name of the file
If you're going to swoop in, make sure to swoop in carefully.
Why isn’t MapDialogRect mapping dialog rectangles?
Maybe you don't have a dialog.
My code crashed when I asked WIL to convert an exception to an HRESULT, did I throw an improper exception type?
Digging into the failure more closely.
That time we had a network outage due to unexpected hunter activity
Watch where you're pointing that thing.
How can I get the screen reader to read out an error message that I displayed inline on a page?
Make it a live region.
What does the SizeOfImage mean in the MODULEINFO structure?
It's the size in terms of mapped address space when loaded.
Why does GetModuleInfo fail to produce an entry point for executables?
Because it's getting the information from the loader, who has no use for such things.
Local variables are different from parameters in C++ coroutines
You tend to think of them the same, but they destruct differently.
The happy hand: A puzzle about odd names in Azure DevOps
Who's renaming everything into something cute?
Is there a way that my macro can detect that it’s running in a C++ coroutine?
You are part of the decision.
What can I do about timer build-up when waiting for COM outbound calls to complete?
You'll have to drain them out yourself.
Debugging coroutine handles: The Microsoft Visual C++ compiler, clang, and gcc
Peeking behind the curtain.
Why is the main() function always at address 0x00401000 in a simple program?
When multiple technical decision add up, literally.
Not from inside the Redmond Reality Distortion Field: Microsoft Streets and Trips support for ferries
From somebody else's reality distortion field.
Some lesser-known powers of std::optional
Things it does that you may not know about.
The subtleties of CreateStreamOnHGlobal, part 4: Non-movable memory
Fear and reallocation.
The subtleties of CreateStreamOnHGlobal, part 3: Suppressing the deletion of a shared HGLOBAL
Trying to set up joint custody.
The subtleties of CreateStreamOnHGlobal, part 2: Suppressing the deletion of an unknown HGLOBAL
You don't know what it is, but you said you don't want it deleted automatically.
The subtleties of CreateStreamOnHGlobal, part 1: Introduction and basic usage
Developing the mental model.
Why am I getting an unresolved external from C++/WinRT if it is a header-only C++ library?
Maybe you didn't get all of the headers.
The case of the UWP application that crashes at launch on Windows 10X
Look before you leap.
Why is there trailing garbage when I try to decode the bytes of a HttpContent object?
You need to know when to stop.
Converting between UTF-8 strings and UTF-16 strings in C++/WinRT
A pair of conversion functions.
The CertUtil program will decode Windows error codes, and in a variety of formats
Even more versatile than <CODE>NET HELPMSG</CODE>.
What does this mean? The caller specified wait timed out before the operation completed because a host termination is in queued
An error message written with infrastructure-colored glasses.
Adventures in application compatibility: The case of the wild instruction pointer that, upon closer inspection, might not be so wild after all
The search for clues leads to an unexpected place.
The C++ implicit assignment operator is a non-ref-qualified member, even if the base class’s assignment has a ref-qualifier
Does that count as dis-qualification?
How do I set the alpha channel of a GDI bitmap to 255?
Most things destroy the alpha channel, but there's a way to bring it back, or at least make it opaque.
Microspeak: Persona
A template for a prototypical user.
The C++/WinRT query_interface_tearoff extension point, and using it for COM aggregation
For adding your own <CODE>QueryInterface</CODE> magic.
Ordering asynchronous updates with coroutines, part 5: Bowing out via cancellation
Using the built-in way of stopping a coroutine.
Ordering asynchronous updates with coroutines, part 4: Bowing out, explicit version
Realizing you're not the one.
Ordering asynchronous updates with coroutines, part 3: Let them all compete, but only one wins
Everybody tries, but only one wins.
Ordering asynchronous updates with coroutines, part 2: Restart with hand-off
Everybody just waits their turn.
Ordering asynchronous updates with coroutines, part 1: Mutual exclusion
Everybody just waits their turn.
I declared my Windows Runtime method as accepting an array by reference, but it always arrives empty
You were only meant to put things into the box, not look at what was already there.