Abstract

This study presents a structured approach to learning PowerShell fundamentals using a laboratory-style methodology. Through a series of carefully designed command sequences, we demonstrate PowerShell’s capabilities for file manipulation, system information retrieval, and basic scripting. Results indicate that PowerShell provides significant advantages over traditional command-line interfaces, enabling both simple task automation and complex system administration. The standardized command structure and object-oriented nature of PowerShell make it an essential tool for Windows system administration and automation tasks.

Introduction

PowerShell is a command-line shell and scripting language developed by Microsoft specifically for system administration and automation tasks. Unlike traditional command-line interfaces, PowerShell is built on the .NET Framework and leverages object-oriented design principles, allowing it to work with structured data rather than simple text streams.¹ Since its introduction in 2006, PowerShell has evolved to become the primary administrative interface for Windows systems, and with the release of PowerShell Core (version 6.0) in 2018, it has expanded to a cross-platform tool supporting Windows, macOS, and Linux.²

The command structure in PowerShell follows a consistent “verb-noun” naming convention, making it more intuitive than traditional command lines. For example, the command Get-Process retrieves running processes, while Stop-Process terminates them.³ This naming pattern enables users to predict command names for unfamiliar tasks, significantly reducing the learning curve for new users.

PowerShell’s utility extends beyond simple command execution to include robust scripting capabilities. Scripts can range from basic task automation to complex system management routines that would otherwise require custom programming solutions. The pipeline architecture allows the output of one command to be passed directly as input to another, enabling the composition of sophisticated operations from simple building blocks.⁴

For this tutorial, we selected commands that demonstrate key PowerShell capabilities across four fundamental areas:

1. File system operations: Creating, modifying, and reading files and directories.
2. Data manipulation: Working with structured data formats like CSV.
3. System information retrieval: Accessing operating system details and service status.
4. Basic scripting: Creating and using functions and variables.

These areas represent the core skills necessary for basic proficiency in PowerShell and serve as a foundation for more advanced functionality. By systematically working through these commands, users can build both theoretical understanding and practical skills in PowerShell usage.

Experimental

Required Materials

• Windows 11 computer with PowerShell installed
• Administrator access (optional, for certain commands)

Procedure

1. Launch PowerShell by pressing Win+X and selecting “Windows Terminal” or “PowerShell”.

2. Execute the following command to verify PowerShell version:

$PSVersionTable

3. Execute the following command to view current directory contents:

Get-ChildItem

4. Create a test directory:

New-Item -Path "$env:USERPROFILE\Documents\PSTest" -ItemType Directory

5. Navigate to the test directory:

Set-Location "$env:USERPROFILE\Documents\PSTest"

6. Create a text file:

"First line of text" | Out-File -FilePath .\test.txt

7. Append content to the text file:

"Second line of text" | Out-File -FilePath .\test.txt -Append

8. Display file content:

Get-Content .\test.txt

9. Create a CSV file with sample data:

@"
Name,Age,City
John,30,New York
Emma,25,London
Miguel,35,Madrid
"@ | Out-File -FilePath .\people.csv

10. Import and display CSV data:

Import-Csv .\people.csv

11. Filter CSV data for specific value:

Import-Csv .\people.csv | Where-Object { $_.Age -gt 25 }

12. Get system date and time:

Get-Date

13. Store command output in a variable:

$processes = Get-Process

14. Display the first 5 processes by memory usage:

$processes | Sort-Object -Property WorkingSet -Descending | Select-Object -First 5

15. Create a basic function:

function Get-TimeInfo {
    $date = Get-Date
    [PSCustomObject]@{
        Date = $date.ToShortDateString()
        Time = $date.ToShortTimeString()
        DayOfWeek = $date.DayOfWeek
    }
}

16. Execute the function:

Get-TimeInfo

17. Create a system dashboard script (press Enter after execution to return to the command prompt):

Write-Host "=== Windows System Dashboard ===" -ForegroundColor Cyan

# Get uptime
$uptime = (Get-Date) - (Get-CimInstance -ClassName Win32_OperatingSystem).LastBootUpTime
Write-Host "Uptime:" -ForegroundColor Green -NoNewline
Write-Host " $($uptime.Days)d $($uptime.Hours)h $($uptime.Minutes)m" -ForegroundColor White

# Get OS version
$os = Get-CimInstance -ClassName Win32_OperatingSystem
Write-Host "OS:" -ForegroundColor Green -NoNewline
Write-Host " $($os.Caption) ($($os.Version))" -ForegroundColor White

# Get CPU info
$cpu = Get-CimInstance -ClassName Win32_Processor
Write-Host "CPU:" -ForegroundColor Green -NoNewline
Write-Host " $($cpu.Name)" -ForegroundColor White

# Get last installed hotfix
$hotfix = Get-HotFix | Sort-Object InstalledOn -Descending | Select-Object -First 1
Write-Host "Latest Hotfix:" -ForegroundColor Green -NoNewline
Write-Host " $($hotfix.HotFixID) (Installed: $($hotfix.InstalledOn))" -ForegroundColor White

Write-Host "==============================" -ForegroundColor Cyan

18. Get information about running services:

Get-Service | Where-Object { $_.Status -eq "Running" } | Select-Object -First 5

19. Return to the home directory:

Set-Location $env:USERPROFILE

Results

The execution of the experimental procedure yielded successful results for all key PowerShell commands. Selected output from various commands is presented below to demonstrate the nature of PowerShell’s responses and data handling capabilities.

System Information Data

Executing the system dashboard script (Step 17) produced the following structured output:

=== Windows System Dashboard ===
Uptime: 45d 15h 48m
OS: Microsoft Windows 11 Pro (10.0.26100)
CPU: Intel(R) Core(TM) i7-10610U CPU @ 1.80GHz
Latest Hotfix: KB5052085 (Installed: 02/23/2025 00:00:00)
==============================

This output demonstrates PowerShell’s ability to retrieve and display system information in a readable format. The system had been running for over 45 days and was using the Windows 11 Pro operating system.

Service Information

The command to retrieve running services (Step 18) produced the following output:

Status   Name               DisplayName
------   ----               -----------
Running  Appinfo            Application Information
Running  AppXSvc            AppX Deployment Service (AppXSVC)
Running  AudioEndpointBu... Windows Audio Endpoint Builder
Running  Audiosrv           Windows Audio
Running  BDESVC             BitLocker Drive Encryption Service

This output displays the first five running services on the system in a tabular format, showcasing PowerShell’s ability to present structured data with clear column headers and aligned values.

Function Execution

When executing the custom function created in Step 15, PowerShell returned an object containing formatted date and time information. This demonstrates PowerShell’s ability to create reusable code components.

File Operations

The file creation and manipulation commands (Steps 6-11) successfully created and modified text files and CSV data. PowerShell’s structured data handling capabilities were particularly evident when filtering CSV data, where it automatically parsed the file format and allowed for property-based filtering.

Discussion

The experimental procedure demonstrated several key aspects of PowerShell that distinguish it from traditional command-line interfaces. The results provide significant insights into PowerShell’s capabilities and practical applications.

Command Structure and Usability

PowerShell’s consistent verb-noun command structure was evident throughout the experiment. Commands like Get-ChildItem, New-Item, and Set-Location follow a predictable pattern that enhances learnability. This structure is one of PowerShell’s most significant advantages over other command-line interfaces, where commands often have historical or arbitrary names.⁴ The consistency allows users to make educated guesses about command names for unfamiliar tasks, reducing the reliance on memorization and documentation.

One challenge observed during the experiment related to indentation and code formatting. Unlike languages such as Python, PowerShell does not rely on indentation for code structure, but proper indentation enhances readability. When creating the function in Step 15, pressing Tab did not automatically indent the code as might be expected in other environments. This is because in PowerShell, Tab is primarily used for command auto-completion rather than indentation. For proper code formatting, users should manually insert spaces or use an integrated development environment (IDE) that supports PowerShell-specific formatting rules.²

Object-Oriented Operations

PowerShell’s object-oriented nature was apparent throughout the experiment. Unlike traditional command-line interfaces that work with text streams, PowerShell commands output structured objects with properties and methods. This was particularly evident in Step 14, where we sorted processes by the WorkingSet property and in Step 11, where we filtered CSV data based on the Age property.

This object-oriented approach offers several advantages. It eliminates the need for text parsing and regular expressions commonly required in other shells. It also ensures consistent data handling; objects maintain their structure as they move through the pipeline, allowing for more reliable automation.³

System Information Retrieval

The system dashboard script created in Step 17 demonstrates PowerShell’s capability to retrieve detailed system information. Commands like Get-CimInstance provide access to Windows Management Instrumentation (WMI) data, which contains comprehensive details about the operating system and hardware configuration. This capability makes PowerShell an essential tool for system administrators who need to inventory and monitor Windows systems.¹

The uptime calculation in particular showcases PowerShell’s ability to perform date calculations directly within scripts. By subtracting the last boot time from the current date, we obtained a precise measure of system uptime that would be cumbersome to calculate in traditional command-line interfaces.

Scripting and Automation

The creation of a function in Steps 15-16 demonstrated PowerShell’s scripting capabilities. Functions allow for code reuse and abstraction, enabling complex operations to be encapsulated in simple commands. The Get-TimeInfo function created in the experiment outputs a custom object with formatted date properties, showcasing PowerShell’s ability to create structured data.

One limitation observed was the requirement to manually define the function in each PowerShell session. In practical scenarios, functions would typically be saved in script files or PowerShell modules for persistence across sessions.⁴ This approach allows for building libraries of reusable functions that can be shared across teams and systems.

Future Directions

While this experiment provided a foundation in PowerShell fundamentals, several advanced topics warrant further exploration. Remote management capabilities through PowerShell remoting would be a logical next step, allowing for the administration of multiple systems from a central location.² Additionally, the PowerShell scripting language includes advanced features like error handling, parameter validation, and module development that enable enterprise-grade automation solutions.

The integration of PowerShell with cloud platforms such as Azure represents another promising direction. Microsoft has developed extensive PowerShell modules for Azure administration, allowing system administrators to apply their PowerShell skills to cloud resource management.³

Acknowledgements

We acknowledge Microsoft’s development of PowerShell as an open-source project and the contributors to the PowerShell documentation. Special thanks to the Windows PowerShell team for their ongoing efforts to improve PowerShell’s capabilities and cross-platform support.

References