Windows admin tools: Settings, MMC, msinfo32

Talking a caller to the About page of Windows takes four dictated clicks, Start, Settings, System and About, and any one of them can go astray on a bad line. Typed into the Run box, the single line ms-settings:about opens the same page at once: it is one of the ms-settings addressesms-settings address: An address beginning with ms-settings: that opens one page of the Windows Settings app, such as ms-settings:about for the About page, taken from the list Microsoft publishes. Microsoft publishes for the pages of Settings.

Those addresses are the first of the built-in tools a technician uses every day. Settings holds most of what can be changed, Control Panel keeps the applets that have not moved, and the snap-inssnap-in: A management tool hosted by the Microsoft Management Console, such as Device Manager, Event Viewer or Services, opened from a console file that may hold several of them. of the Microsoft Management ConsoleMicrosoft Management Console (MMC): The Windows program that hosts administrative tools called snap-ins and saves them in console files ending in .msc, such as devmgmt.msc for Device Manager. (MMC) open by their file names. System Information (msinfo32) and winver give exact facts for a ticket, System Configuration runs a clean boot, and Registry Editor makes the rare change no page covers. You will open each one by name, save a report a vendor can use, and change the registry only after a backup, with the reason in the ticket.

Settings comes first, and one ms-settings line opens a page

Settings is the main app for changing Windows, and Microsoft’s overview of the system tools encourages using it whenever possible. Control Panel is still there, for compatibility and for the settings that have not moved to Settings yet: control in the Run box opens it. On a call, though, what matters most is how fast you reach a page. Most pages of Settings have an address of their own, and ms-settings: is one of the URI schemes built into Windows, so the address works wherever Windows follows a link, the Run box included: press the Windows logo key + R, type the address and press Enter.

The program below turns a table of jobs into a “how to open it” card for a call. Before a line goes on the card, it checks the line against names Microsoft publishes: the addresses on its Launch Windows Settings list and the file names its pages give for the tools. Watch what happens to the printer row:

"""A "how to open it" card for talking a caller through Windows.

Each row of TASKS is a task, the one line that opens it from the Run box
(Windows logo key + R, then Enter) and, where Microsoft documents one, the
menu path that the line replaces. Every line is checked against the names
Microsoft publishes before its row goes on the card, so a mistyped address
is refused here instead of on the phone.
"""

# A few rows of Microsoft's "Launch Windows Settings" list: the address and
# the name of the Settings page it opens, exactly as the list gives them.
SETTINGS_PAGES = {
    "ms-settings:about": "About",
    "ms-settings:windowsupdate": "Windows Update",
    "ms-settings:windowsupdate-history": "Windows Update-View update history",
    "ms-settings:storagesense": "Storage",
    "ms-settings:printers": "Printers & scanners",
    "ms-settings:windowsdefender": "Windows Security",
}

# Tools a technician opens by name, as Microsoft's pages name them.
TOOLS = {
    "devmgmt.msc": "Device Manager, an MMC snap-in",
    "eventvwr.msc": "Event Viewer, an MMC snap-in",
    "msinfo32": "System Information",
    "control": "Control Panel",
}

# (task, the line to type, the menu path it replaces or None)
TASKS = [
    ("Read the edition, version and build", "ms-settings:about",
     "Start > Settings > System > About"),
    ("See what is filling the disk", "ms-settings:storagesense",
     "right-click Start > Settings > System > Storage"),
    ("Check for updates", "ms-settings:windowsupdate", None),
    ("List the updates installed so far", "ms-settings:windowsupdate-history", None),
    ("Add a printer", "ms-settings:printer", None),
    ("Look for a device with a problem", "devmgmt.msc", None),
    ("Open the event logs", "eventvwr.msc", None),
    ("Read the full system summary", "msinfo32", None),
    ("Reach an applet not moved to Settings", "control", None),
]


def opens(line):
    """What the line opens, or None when Microsoft's names do not include it."""
    if line.startswith("ms-settings:"):
        page = SETTINGS_PAGES.get(line)
        return f"the Settings page {page}" if page else None
    return TOOLS.get(line)


card, refused = [], []
for task, line, path in TASKS:
    target = opens(line)
    if target is None:
        refused.append((task, line))
    else:
        card.append((task, line, target, path))

print("How to open it: press the Windows logo key + R, type the line, press Enter")
print()
paths, clicks = 0, 0
for number, (task, line, target, path) in enumerate(card, start=1):
    print(f"{number:>2}  {task}")
    print(f"    Type:    {line}")
    print(f"    Opens:   {target}")
    if path:
        steps = len(path.split(" > "))
        paths, clicks = paths + 1, clicks + steps
        print(f"    Instead: {path} ({steps} clicks)")
    print()

for task, line in refused:
    print(f"Refused: {task}")
    print(f"    {line} is not on Microsoft's list. Copy the address letter for letter.")
    print()

print(f"{len(card)} rows on the card, {len(refused)} refused.")
print(f"{paths} menu paths of {clicks} clicks in all, replaced by {paths} typed lines.")

How to open it: press the Windows logo key + R, type the line, press Enter

 1  Read the edition, version and build
    Type:    ms-settings:about
    Opens:   the Settings page About
    Instead: Start > Settings > System > About (4 clicks)

 2  See what is filling the disk
    Type:    ms-settings:storagesense
    Opens:   the Settings page Storage
    Instead: right-click Start > Settings > System > Storage (4 clicks)

 3  Check for updates
    Type:    ms-settings:windowsupdate
    Opens:   the Settings page Windows Update

 4  List the updates installed so far
    Type:    ms-settings:windowsupdate-history
    Opens:   the Settings page Windows Update-View update history

 5  Look for a device with a problem
    Type:    devmgmt.msc
    Opens:   Device Manager, an MMC snap-in

 6  Open the event logs
    Type:    eventvwr.msc
    Opens:   Event Viewer, an MMC snap-in

 7  Read the full system summary
    Type:    msinfo32
    Opens:   System Information

 8  Reach an applet not moved to Settings
    Type:    control
    Opens:   Control Panel

Refused: Add a printer
    ms-settings:printer is not on Microsoft's list. Copy the address letter for letter.

8 rows on the card, 1 refused.
2 menu paths of 8 clicks in all, replaced by 2 typed lines.

Eight rows made the card. The two jobs that also had a menu path needed 8 clicks between them, every one dictated and confirmed; their typed lines are 2. The ninth row was refused: ms-settings:printer is one letter short of an address on the list, the kind of slip that is easy to make and hard to hear on a call. Microsoft’s list also says that some pages exist only on some versions and editions of Windows, so copy an address from the list, letter for letter.

Control Panel still holds a few jobs a desk meets every week. When an app cannot be uninstalled from Settings, Microsoft’s steps go to Control Panel, then Programs, then Programs and Features. Saved passwords for websites and networks live in Credential Manager, a Control Panel applet. Windows Tools, the folder of administrative tools, is itself a Control Panel folder. An applet also opens directly: control /name with the applet’s canonical name, as in control /name Microsoft.ProgramsAndFeatures, is the way Microsoft prefers to start one from a command line.

One more behaviour saves a wasted call. An organisation can hide Settings pages on its devices, such as kiosks and student laptops, with a page visibility policy, and a hidden page cannot be reached by its address either: Windows opens the first page of Settings instead. When an address you know is right lands there, ask who manages the device before you look for a fault.

Snap-ins open by file name inside one console

Device Manager, Disk Management and Event Viewer look like separate programs, but each one is a snap-in, a tool hosted by MMC. MMC gives them one framework and one look, and it saves them in console files that end in .msc. Microsoft’s reference for the mmc command shows the pattern: mmc followed by a console file opens that console, and mmc alone opens an empty one. The command works in the Run box, at a command prompt, in a shortcut or in a script, so a caller types only the console’s file name, as Microsoft’s own steps do with diskmgmt.msc and lusrmgr.msc.

The table lists the consoles a desk opens every day, each name taken from a Microsoft page:

This lesson only opens them; the rest of the module works inside them. Device Manager’s problem codes and driver fixes are in Windows apps, drivers and Device Manager, Event Viewer’s logs and filters in Slow PCs, crashes and Event Viewer, local accounts and groups in Windows accounts, UAC and user profiles, and the Group Policy a PC receives in Windows command line for support work.

Two names in the table deserve a second look. certmgr.msc opens Certificates - Current User, the store of whoever is signed in; a certificate installed for the whole computer sits in the local computer’s store, which certlm.msc opens. And gpedit.msc is missing on some PCs by design: Microsoft notes that the Local Group Policy Editor is not available on Windows Home. A tool that will not open can be a clue to the edition before it is a fault, and ms-settings:about shows the edition in seconds.

Where Windows keeps these tools also says who they are for. Microsoft’s Windows Tools folder, meant for system administrators and advanced users, holds Computer Management, Event Viewer, Services, Task Scheduler, Performance Monitor and System Information. Task Manager and Resource Monitor are there too, and both are worked through in Slow PCs, crashes and Event Viewer. Ctrl+Shift+Esc opens Task Manager, and its Startup apps tab returns in the clean boot below.

System Information and winver put exact facts in the ticket

A vendor’s engineer asks three things before they will help with a crashing app: the exact Windows version and build, the BIOS mode, and whether Secure Boot is on. Each answer has a tool that reads it and changes nothing. The table shows where each fact sits:

winver is the quickest of them, typed in the search box or at a command prompt, and the About page adds the edition. What a version means, and how long its updates last, belongs to operating systems, editions and support dates; here the point is to copy the numbers from the screen, never from memory.

System Information is the full picture: msinfo32 opens a view of the hardware, the system components and the software of the PC, with the System Summary first. Microsoft’s own troubleshooting steps read BIOS Mode (UEFI or Legacy) and Secure Boot State there, and the features of virtualisation-based security appear at the bottom of the same summary. Microsoft also advises opening the tool with administrator rights, so that its list of drivers and services is accurate. It saves what it shows in two forms of System Information reportSystem Information report: A file that System Information (msinfo32) saves about a PC: plain text with the /report switch, or with /nfo a file that the tool can open again.:

• msinfo32 /report C:\Temp\PC-07.txt writes plain text under exactly the name you give. It never adds .txt by itself, so type the extension when you want one.
• msinfo32 /nfo C:\Temp\PC-07.nfo writes System Information’s own file, adding .nfo when the name lacks it, so the report can be browsed in the tool on another computer.
• /categories +systemsummary limits a run to the summary, as in Microsoft’s example msinfo32 /nfo syssum.nfo /categories +systemsummary, and /computer reads a remote PC you have permission to reach.

A report describes one person’s PC in detail, and a ticket is read by many people. Before you attach one, read it through and keep only what answers the question; the PII redactor masks names and other personal details in text you are about to paste.

A clean boot tells Windows apart from the software added to it

An accounting app crashes at every start on one PC and works on all the others. The cause may be Windows itself, or something another maker added to it, such as a service or a startup app. A clean bootclean boot: Starting Windows with only essential drivers and startup programs, with the services and startup apps of other software turned off, to show whether that software causes a fault. separates the two. Microsoft describes it as starting Windows with only essential drivers and startup programs, and says that, unlike Safe Mode, it gives more control in isolating the cause. The tool is System Configuration, msconfig, whose tabs are General, Boot, Services, Startup and Tools; its Startup tab now sends you to Task Manager. Step through Microsoft’s routine and its two outcomes:

Two steps carry the whole method. Hide all Microsoft services comes before Disable all, so Windows keeps its own services and only the ones other software added are switched off. And the list of startup apps you disable is the way back: without it, nobody knows which ones to turn on again. If the fault survives the clean boot, no other app or service is causing it, and the app’s maker is the next stop. If the fault goes away, turning half of the suspects back on at each restart finds the culprit fast, the same halving that finds one culprit among 64 in six restarts in a troubleshooting method that holds under pressure.

System Configuration changes how Windows starts, so Microsoft’s caution applies to every visit: back up first, follow the steps in order, and change its advanced boot options only with a Microsoft support engineer’s guidance. On a PC an organisation manages, network policy may prevent the routine, which is a reason to involve the team that manages it.

Export the key before you change the registry

Ticket INC-2041: a user’s files always open read-only in their viewer app, and the app’s support page names the value that controls it. The value lives in the registryWindows registry: The hierarchical database in which Windows and many applications keep their settings, arranged as keys under five root keys such as HKLM and HKCU., the database where Windows and many applications keep their low-level settings, arranged as a tree. Each node of the tree is a keyregistry key: One node of the registry tree, written as a path such as HKCU\Software\ExampleCo, that holds subkeys and values, each value with a name, a type and data.; a key holds subkeys and values, and each value has a name, a type and its data. Key names are not case sensitive and never contain a backslash, which is why backslashes separate them in a path such as HKCU\Software\ExampleCo\Viewer.

A path starts at one of the five root keys that reg accepts. HKLM (HKEY_LOCAL_MACHINE) holds the computer’s settings for any user, HKCU (HKEY_CURRENT_USER) those of the user who is signed in, HKCR (HKEY_CLASSES_ROOT) which program opens which file, HKU (HKEY_USERS) every loaded user profile, and HKCC (HKEY_CURRENT_CONFIG) the hardware profile used at startup. The types a desk meets most are REG_SZ, a string, and REG_DWORD, a number 4 bytes long.

Microsoft’s advice is plain: change settings through the Windows interface rather than by editing the registry, and expect that a wrong edit may mean reinstalling Windows. When the registry is the only way, the routine never changes: export the key, change one value, test, note it in the ticket and keep the backup so the change can be put back. The program below plans four tickets that way. Look at what it does with the third and the fourth:

"""Plan registry changes the safe way, one ticket at a time.

For each planned change the program prints five steps: export the key,
change one value, test, write the ticket note, and the command that puts
the exported data back. A change that a Settings page covers gets the page
instead, and a key outside the five root keys is refused.

The keys and values are a sample for a made-up program, ExampleCo Viewer.
The commands follow Microsoft's pages for reg export and reg import.
"""

ROOT_KEYS = ("HKLM", "HKCU", "HKCR", "HKU", "HKCC")

PLANNED = [
    {"ticket": "INC-2041", "why": "files always open read-only",
     "key": r"HKCU\Software\ExampleCo\Viewer",
     "value": "OpenReadOnly", "type": "REG_DWORD", "old": "1", "new": "0",
     "test": "open a document, edit it and save it"},
    {"ticket": "INC-2044", "why": "the recent-files list stops at 4",
     "key": r"HKCU\Software\ExampleCo\Viewer\Recent",
     "value": "MaxItems", "type": "REG_DWORD", "old": "4", "new": "10",
     "test": "open five files, then look at the list"},
    {"ticket": "INC-2049", "why": "use the office proxy for one user",
     "setting": "ms-settings:network-proxy"},
    {"ticket": "INC-2052", "why": "turn on the viewer's detailed log",
     "key": r"HKLN\SOFTWARE\ExampleCo\Viewer",
     "value": "LogLevel", "type": "REG_SZ", "old": "warn", "new": "debug",
     "test": "repeat the steps that crash it, once"},
]


def plan(change):
    """The lines of one plan, or a refusal."""
    lines = [f"{change['ticket']}: {change['why']}"]
    if "setting" in change:
        lines.append(f"  A Settings page covers this: open {change['setting']}.")
        lines.append("  No registry edit, so there is nothing to back up or undo.")
        return lines, "setting"
    key = change["key"]
    parts = key.split("\\")
    if parts[0] not in ROOT_KEYS:
        lines.append(f"  Refused: {parts[0]} is not a root key. Use one of {', '.join(ROOT_KEYS)}.")
        return lines, "refused"
    backup = f"{change['ticket']}-{parts[-1]}.reg"
    lines += [
        f'  1 Back up  reg export "{key}" "{backup}"',
        f"  2 Change   {change['value']} ({change['type']}): {change['old']} to {change['new']}, nothing else",
        f"  3 Test     {change['test']}",
        f"  4 Note     exported {key} to {backup};",
        f"             set {change['value']} from {change['old']} to {change['new']}",
        f'  5 Undo     reg import "{backup}"',
    ]
    return lines, "registry"


counts = {"registry": 0, "setting": 0, "refused": 0}
for change in PLANNED:
    lines, kind = plan(change)
    counts[kind] += 1
    print("\n".join(lines))
    print()

print(f"{counts['registry']} registry plans, {counts['refused']} refused, "
      f"{counts['setting']} done in Settings instead.")

INC-2041: files always open read-only
  1 Back up  reg export "HKCU\Software\ExampleCo\Viewer" "INC-2041-Viewer.reg"
  2 Change   OpenReadOnly (REG_DWORD): 1 to 0, nothing else
  3 Test     open a document, edit it and save it
  4 Note     exported HKCU\Software\ExampleCo\Viewer to INC-2041-Viewer.reg;
             set OpenReadOnly from 1 to 0
  5 Undo     reg import "INC-2041-Viewer.reg"

INC-2044: the recent-files list stops at 4
  1 Back up  reg export "HKCU\Software\ExampleCo\Viewer\Recent" "INC-2044-Recent.reg"
  2 Change   MaxItems (REG_DWORD): 4 to 10, nothing else
  3 Test     open five files, then look at the list
  4 Note     exported HKCU\Software\ExampleCo\Viewer\Recent to INC-2044-Recent.reg;
             set MaxItems from 4 to 10
  5 Undo     reg import "INC-2044-Recent.reg"

INC-2049: use the office proxy for one user
  A Settings page covers this: open ms-settings:network-proxy.
  No registry edit, so there is nothing to back up or undo.

INC-2052: turn on the viewer's detailed log
  Refused: HKLN is not a root key. Use one of HKLM, HKCU, HKCR, HKU, HKCC.

2 registry plans, 1 refused, 1 done in Settings instead.

Two plans came out complete, each with a backup named after its ticket and its key: INC-2041-Viewer.reg and INC-2044-Recent.reg. Ticket INC-2049 needed no registry at all, because a Settings page, ms-settings:network-proxy, covers it. Ticket INC-2052 was refused: HKLN is a typo for HKLM, and reg export accepts only a valid root key.

Follow the first plan through its steps:

The flow used both commands of the plan. reg export copies a key with all its subkeys and values into a .reg file, and reg import copies them back. Registry Editor (regedit) does the same from its menus with File > Export and File > Import; Windows may first ask for an administrator’s password or confirmation. Leave out /y: it makes reg export overwrite an existing file of the same name without asking, which is how an earlier backup gets lost.

Four questions pick the right tool

Three tickets from this lesson show the choice. Setting the office proxy for one user has a Settings page, so plan INC-2049 used it. A vendor who wants the BIOS mode needs a tool that reads and changes nothing, System Information. And the viewer’s read-only value, which no page covers, needed the registry, with its export first. Four questions about the job decide most cases. Answer them in the table and watch which tools stay in:

In short: a Settings page when Microsoft’s list has one, Control Panel for an applet that has not moved, a snap-in by its file name for devices, disks, services and logs, System Information and winver to read facts, and Registry Editor last, after an export, when nothing else reaches the setting. On the phone, prefer whatever has one exact line to dictate, and connect to the PC yourself before anyone touches the registry.

Practise: the backup line for any key

Every registry plan in this lesson began with one line, the export. Write the function that builds it from a key and a ticket number: it writes the root in its short form, names the backup after the ticket and the key, and refuses a key it cannot safely back up, before a typo reaches a user’s PC. Then test yourself on the whole lesson.

def reg_export_command(key, ticket):
    """Return the reg export command that backs up key before the change made for ticket."""
    return "reg export"

from reg_export import reg_export_command


def refused(key, ticket="INC-1"):
    """True when reg_export_command raises ValueError for this key and ticket."""
    try:
        reg_export_command(key, ticket)
    except ValueError:
        return True
    return False


def test_backup_named_after_the_ticket():
    """quotes the key and names the backup after the ticket and the last key name"""
    assert reg_export_command(r"HKCU\Software\ExampleCo\Viewer", "INC-2041") == (
        r'reg export "HKCU\Software\ExampleCo\Viewer" "INC-2041-Viewer.reg"'
    )
    assert reg_export_command(r"HKLM\SOFTWARE\ExampleCo\Agent", "CHG-88") == (
        r'reg export "HKLM\SOFTWARE\ExampleCo\Agent" "CHG-88-Agent.reg"'
    )


def test_long_root_names_become_short():
    """writes each of the five long root names in its short form"""
    assert reg_export_command(r"HKEY_LOCAL_MACHINE\SOFTWARE\ExampleCo\Agent", "CHG-88") == (
        r'reg export "HKLM\SOFTWARE\ExampleCo\Agent" "CHG-88-Agent.reg"'
    )
    assert reg_export_command(r"HKEY_CURRENT_USER\Software\ExampleCo", "INC-4") == (
        r'reg export "HKCU\Software\ExampleCo" "INC-4-ExampleCo.reg"'
    )
    assert reg_export_command(r"HKEY_CLASSES_ROOT\ExampleCo.Document", "INC-77") == (
        r'reg export "HKCR\ExampleCo.Document" "INC-77-ExampleCo.Document.reg"'
    )
    assert reg_export_command(r"HKEY_USERS\.DEFAULT\Control Panel\Desktop", "INC-12") == (
        r'reg export "HKU\.DEFAULT\Control Panel\Desktop" "INC-12-Desktop.reg"'
    )
    assert reg_export_command(r"HKEY_CURRENT_CONFIG\Software\ExampleCo", "INC-31") == (
        r'reg export "HKCC\Software\ExampleCo" "INC-31-ExampleCo.reg"'
    )


def test_root_in_any_letter_case():
    """accepts a root typed in lower or mixed case"""
    assert reg_export_command(r"hkcu\Software\ExampleCo\Viewer", "INC-5") == (
        r'reg export "HKCU\Software\ExampleCo\Viewer" "INC-5-Viewer.reg"'
    )
    assert reg_export_command(r"Hkey_Users\.DEFAULT\Environment", "INC-6") == (
        r'reg export "HKU\.DEFAULT\Environment" "INC-6-Environment.reg"'
    )


def test_one_name_after_the_root_is_enough():
    """backs up a key that sits right under its root"""
    assert reg_export_command(r"HKCU\Environment", "INC-3") == (
        r'reg export "HKCU\Environment" "INC-3-Environment.reg"'
    )


def test_trailing_backslash_and_spaces():
    """drops a backslash at the end and turns spaces into hyphens in the file name only"""
    assert reg_export_command("HKCU\\Software\\ExampleCo\\Viewer\\", "INC-8") == (
        r'reg export "HKCU\Software\ExampleCo\Viewer" "INC-8-Viewer.reg"'
    )
    assert reg_export_command(r"HKCU\Software\ExampleCo\Saved Views", "INC-9") == (
        r'reg export "HKCU\Software\ExampleCo\Saved Views" "INC-9-Saved-Views.reg"'
    )


def test_refuses_keys_it_cannot_back_up():
    """raises ValueError for a wrong root, a root alone and an empty name"""
    assert refused(r"HKLN\SOFTWARE\ExampleCo")
    assert refused(r"HKEY_LOCAL\SOFTWARE\ExampleCo")
    assert refused(r"Software\ExampleCo\Viewer")
    assert refused("HKCU")
    assert refused("HKCU\\")
    assert refused(r"HKCU\Software\\ExampleCo")
    assert refused("")


def test_refuses_tickets_that_make_bad_file_names():
    """raises ValueError for an empty ticket or one with spaces or slashes"""
    assert refused(r"HKCU\Software\ExampleCo", "")
    assert refused(r"HKCU\Software\ExampleCo", "INC 2041")
    assert refused(r"HKCU\Software\ExampleCo", "INC/2041")
    assert not refused(r"HKCU\Software\ExampleCo", "inc-2041")

Interview questions

Warm-up (fresher): For a technician on a call, how are Settings and Control Panel different?

Settings is the main app for changing Windows, and Microsoft encourages using it whenever possible. Control Panel is the older one, kept for compatibility and for the settings that have not moved yet, such as Programs and Features for an app that Settings cannot uninstall, or Credential Manager. For a technician the bigger difference is reach. Most Settings pages have an ms-settings address on Microsoft’s list, so on a call I dictate one line for the Run box, such as ms-settings:windowsupdate, instead of a menu path. Control Panel opens with control, and one applet with control /name and its canonical name. I copy addresses exactly, because some pages exist only on some versions and editions, and on a managed PC a policy can hide a page, which then opens the first page of Settings instead.

Two harder questions take the lesson beyond its own tickets: a vendor’s registry change for a whole office, and a console that opens without its tool on a managed PC. Plan your first three steps for each before you open it:

Key takeaways

• Settings is the main app and Control Panel keeps the applets that have not moved; most Settings pages have an ms-settings address on Microsoft’s list, one exact line to dictate instead of a menu path.
• Snap-ins run inside the Microsoft Management Console and open by their file names, such as devmgmt.msc, eventvwr.msc and services.msc, and a tool missing on one PC, such as gpedit.msc on Home, is a clue to its edition.
• The About page, winver and System Information read exact facts without changing anything, and msinfo32 /report saves them as text under exactly the name you type.
• A clean boot keeps Microsoft’s services and turns off what other software added; a fault that survives it is not caused by another app or service, and the PC goes back to a normal start when you are done.
• Change the registry only when no setting covers the job: export the key first, change one value, test, note it in the ticket and keep the .reg file so reg import can undo it.
• Four questions choose the tool: whether a page exists, whether you will change or only read, whether you are on the phone, and whether an administrator is at hand.