PowerShell

Verb-Noun names make PowerShell predictable and searchable: the verb comes from an approved list describing the action, the noun names the thing acted on. Because the shape is uniform, Get-Command can filter by verb or noun and Get-Help documents any command you find.

A .psm1 file holds the module's actual code — its function definitions. A .psd1 manifest holds metadata about the module as a PowerShell hashtable: version, GUID, author, dependencies, and the exact list of commands the module exports.

Enter-PSSession opens an interactive prompt on one remote machine, so you type commands there and see results immediately. Invoke-Command sends a script block to one or many machines, runs it there, and returns the results into your local session.

@() builds an array — an ordered list of values indexed by position. @{} builds a hashtable — unordered key/value pairs. Append to an array with $a += $item; add or update a hashtable entry with $h['key'] = $value.

They are two separate products installed side by side. Windows PowerShell 5.1 (powershell.exe) runs on .NET Framework and reports PSEdition Desktop; PowerShell 7 (pwsh) is a separate cross-platform install on modern .NET and reports Core.

Most cmdlet failures are non-terminating errors: they write a record to the error stream and execution continues, so try/catch never fires. Adding -ErrorAction Stop turns that call's errors into terminating ones, which a catch block handles.

Objects crossing a PowerShell remoting boundary are serialized to XML and rebuilt on the other side as inert property bags. The returned object carries the remote object's property values but not its live methods or its connection to the remote process, so .Kill() does not exist.

[CmdletBinding()] turns a simple PowerShell function into an advanced function: it inherits the common parameters (-Verbose, -Debug, -ErrorAction, -ErrorVariable, -OutVariable and friends), gains access to $PSCmdlet, and binds arguments strictly instead of dumping extras into $args.

PowerShell 7 defines the automatic variables $IsWindows, $IsLinux and $IsMacOS for OS detection. Build paths with Join-Path rather than hardcoded backslashes, use $HOME instead of $env:USERPROFILE, and spell environment variable names exactly, since Unix names are case-sensitive.

throw raises a terminating error that unwinds to the nearest catch and stops the current scope. Write-Error emits a non-terminating error record on the error stream and execution continues with the next statement.

The foreach statement evaluates its whole collection into memory first, then loops over it quickly. ForEach-Object is a cmdlet that streams: it runs its script block on each item as it arrives, so it composes inside a pipeline and holds constant memory, at a higher per-item cost.

Format-Table does not reshape your data, it replaces it with internal formatting-instruction objects that only the output cmdlets understand. Anything placed after a Format-* cmdlet therefore receives display instructions, not process objects. Format for humans last; use Select-Object or Export-Csv for data.

A DSC configuration compiles into one MOF document per target node describing desired state. The Local Configuration Manager agent on the node applies it: in push mode you send the MOF with Start-DscConfiguration; in pull mode the agent fetches it on a schedule and can re-correct drift.

Put a .NET exception type in brackets after the catch keyword, such as catch [System.IO.IOException], and order blocks from most specific to most general. Inside, $_ is an ErrorRecord holding the exception, target object, category and script stack trace.

PowerShell scans the directories listed in the PSModulePath environment variable, indexes the commands each module exports, and imports the owning module automatically the first time you invoke one of those commands. Explicit Import-Module is only needed to force a specific module or version.

New-PSSession creates a persistent remote runspace you reuse across calls, so connection setup and authentication happen once and state such as variables and imported modules survives between commands. Each Invoke-Command -ComputerName call instead builds a throwaway session and tears it down.

In PowerShell every expression whose value is not captured, assigned or redirected goes to the function's output stream. return only exits the scope and adds its argument to what was already emitted. Discard unwanted values with $null = expression, void, or | Out-Null.

A function body with no named blocks is treated entirely as the end block, which runs once after the pipeline is exhausted. The pipeline parameter is rebound for each incoming object, so by the time that code runs it holds only the last one. Per-item logic belongs in a process block.

Sort-Object is a blocking stage: it cannot emit anything until it has received every input object, so it holds the entire filtered stream in memory. Where-Object, ForEach-Object and Select-Object -First stream one object at a time. Reduce or project before sorting, or avoid sorting.

PowerShell 6 removed the WMI cmdlets in favour of the CIM cmdlets, and modules whose manifest omits Core from CompatiblePSEditions refuse to load. On Windows, Import-Module -UseWindowsPowerShell proxies such a module through a background 5.1 process.

Pair -ErrorAction SilentlyContinue with -ErrorVariable on the call inside the loop, prefixing the variable name with a plus sign so each error record is appended rather than overwriting the last. $Error is session-wide, capped, and mixed with unrelated failures.

PowerShell installs modules side by side in versioned subfolders and, when you do not ask for a version, imports the highest one it finds. Determinism comes from pinning: Import-Module -RequiredVersion, a #Requires -Modules hashtable, manifest RequiredModules, or vendoring with Save-Module.

WS-Man is the Windows-native transport: SOAP over HTTP on ports 5985/5986, integrated with Windows authentication and session configurations. SSH transport tunnels PowerShell over an existing SSH connection, works uniformly on Linux and macOS, and uses SSH keys, but drops WS-Man-only features such as disconnected sessions.

PowerShell arrays are fixed-size .NET arrays, so each += allocates a new array one element longer and copies every existing element — quadratic work plus heavy garbage. Use a List[T] with .Add(), or let the loop stream its output and assign the whole loop once.

Batch the fleet and let Invoke-Command fan out with a tuned -ThrottleLimit (default 32) rather than hand-rolling parallelism. Reuse sessions for multi-step work, run batches as jobs, tag every result with PSComputerName, and treat unreachable hosts as expected data rather than failures.

Select-Object with a property list does not trim the original object — it builds a brand-new PSCustomObject carrying only the named properties as plain values. The original .NET type, and therefore every method on it such as Kill(), is gone.

An external program is a separate process that reports failure with an exit code, not with a PowerShell error record, so try/catch and $ErrorActionPreference never see it. Check $LASTEXITCODE after the call and throw yourself.

Implicit remoting imports a remote session's commands into your local session as proxy functions. The names, parameters and tab completion are local; the actual execution happens in the remote runspace, and results come back deserialized like any other remoting output.

They solve different problems: Terraform provisions infrastructure, Ansible pushes configuration on demand, and DSC runs an on-node agent that can continuously correct drift on Windows. Choose by whether you need continuous convergence, how strong your Linux story must be, and whether rebuilding beats converging.