Windows PowerShell

PowerShell is a task automation and configuration management framework consisting of a command-line shell and a scripting language. While traditional shells communicate using text streams, PowerShell is built on top of the .NET Common Language Runtime (CLR) and processes structured .NET objects.

The Core Difference: Objects vs Text

In traditional Unix-like shells (such as Bash), command inputs and outputs are flat streams of text. Filtering or aggregating results requires parsing characters, columns, and delimiters using tools like awk, sed, or cut.

In PowerShell, the output of a command (known as a cmdlet) is a sequence of structured .NET objects. Each object maintains typed properties and methods.

For example, when listing files, instead of parsing a directory table as text, PowerShell yields a collection of System.IO.FileInfo objects:

# Example: Inspecting the object type returned by Get-ChildItem
$items = Get-ChildItem -Path "."

# Query the full .NET class type of the returned object
$items[0].GetType().FullName
# Output: System.IO.FileInfo (or System.IO.DirectoryInfo)

# Extract specific properties directly without regex or text cutting
$items | Select-Object -Property Name, Length, LastWriteTime

rectangle "Command: Get-Service" as cmd
rectangle "Pipeline" as pipe
rectangle "Output Object" as obj

note right of obj
Status: Running
Name: wuauserv
DisplayName: Windows Update
end note

cmd -> pipe
pipe -> obj

Verb-Noun Syntax

To make commands discoverable and consistent, PowerShell utilizes a strict Verb-Noun naming convention.

• Verbs: Represent the action (e.g., Get, Set, New, Remove, Start, Stop).
• Nouns: Represent the resource target (e.g., Service, Process, Item, Content).

For example, finding, checking, and creating files and folders is performed via standard cmdlets:

# Example: Discovering cmdlets related to processes
Get-Command -Verb Get -Noun Process

# Creating a new directory and writing content to a file
New-Item -Path ".\demo_folder" -ItemType "Directory"
New-Item -Path ".\demo_folder\settings.conf" -ItemType "File" -Value "max_connections=128"

The Pipeline on Steroids

Because the pipeline operator (|) passes complete .NET objects rather than flat text, subsequent pipeline stages can filter, sort, group, and modify objects by querying their properties directly.

For example, a pipeline can filter active system processes, sort them by CPU consumption, and terminate processes exceeding a resource threshold:

# Example: Filtering, sorting, and stopping processes via the pipeline
Get-Process | 
  Where-Object { $_.CPU -gt 10.0 } | 
  Sort-Object -Property CPU -Descending | 
  Select-Object -First 3

In this pipeline, $_ acts as a placeholder variable representing the current object traversing the pipeline.

Essential PowerShell Commands (and their Unix Aliases)

PowerShell provides built-in transition aliases that match standard Unix commands. However, these aliases are only shortcuts pointing to PowerShell cmdlets.

For example, developers can query the raw cmdlet behind an alias using Get-Alias:

# Example: Resolving an alias to its source cmdlet
Get-Alias -Name ls

# Output:
# CommandType     Name                                               Version    Source
# -----------     ----                                               -------    ------
# Alias           ls -> Get-ChildItem

Power in the Enterprise: Active Directory and Azure

PowerShell includes support for enterprise-wide remote administration using WS-Management (WSMan) protocols and the Common Information Model (CIM).

For example, executing commands remotely across multiple network servers concurrently:

# Example: Querying service states on remote hosts using WinRM
Invoke-Command -ComputerName "Server-01", "Server-02" -ScriptBlock {
    Get-Service -Name "wuauserv" | Select-Object -Property MachineName, Status
}

This model executes the command block on the target servers and returns the serialized results back to the caller’s console.

PowerShell Core (pwsh)

Originally bound to the Windows-only .NET Framework, Microsoft refactored PowerShell to run on top of the cross-platform .NET Core runtime, renaming it PowerShell Core (pwsh). It runs natively on Linux, macOS, and Windows.

For example, invoking a cross-platform command script to retrieve and parse JSON data on a Linux server:

# Example: Launching pwsh from Linux to extract information from package.json
pwsh -Command "Get-Content -Raw -Path ./package.json | ConvertFrom-Json | Select-Object -ExpandProperty dependencies"

Which shell should you use?

The choice between shells depends on the system environment and data format.

Bash (Unix Shell)

• Strengths: Fast execution, native system integration on Linux/macOS, large ecosystem of text filters (awk, sed, grep).
• Weakness: Text parser commands are fragile and can break if column spacing or output fields change.

PowerShell

• Strengths: Strict object properties mean scripts rarely break when outputs change; deep integration with structured formats (JSON, XML, CSV).
• Weakness: Higher startup time due to the underlying CLR runtime.

For example, comparing log filtering in Bash vs. PowerShell:

# Example scenario: Bash text-based search
grep -i "error" production.log | wc -l

# Example scenario: PowerShell structured log processing
(Get-Content -Raw production.log | ConvertFrom-Json) | 
  Where-Object { $_.Level -eq "Error" } | 
  Measure-Object | 
  Select-Object -ExpandProperty Count

# Filter processes in the pipeline where the CPU property exceeds 50 units
Get-Process | Where-Object { $_.CPU -gt 50 }

# Filter processes in the pipeline where the CPU property exceeds 50 units
Get-Process | Where-Object { .CPU -gt 50 }

References & Further Reading

• Holmes, S. (2021). PowerShell Cookbook: Your Shortcut to Windows PowerShell and PowerShell Core (4th ed.). O’Reilly Media.
• Kopczynski, M., & Siddaway, R. (2017). Learn Windows PowerShell in a Month of Lunches (3rd ed.). Manning Publications.
• Microsoft Corporation. (n.d.). PowerShell Core Documentation. Microsoft Learn.
• PowerShell GitHub Repository (MIT License).