Terminating vs non-terminating errors in PowerShell - Trade-offs & Expert Analysis

Overview - Terminating vs non-terminating errors

What is it?

In PowerShell, errors are problems that happen when a script or command runs. There are two main types: terminating errors and non-terminating errors. Terminating errors stop the script immediately, while non-terminating errors let the script keep running but report the problem. Understanding these helps you control how your scripts behave when something goes wrong.

Why it matters

Without knowing the difference, you might not handle errors properly. This can cause scripts to stop unexpectedly or ignore serious problems. Proper error handling makes your scripts reliable and easier to fix when issues happen. It helps avoid surprises and keeps automation smooth and predictable.

Where it fits

Before learning this, you should know basic PowerShell commands and how to run scripts. After this, you can learn about advanced error handling techniques like try/catch blocks and custom error actions.

Mental Model

Core Idea

Terminating errors stop your script immediately, while non-terminating errors report problems but let the script continue.

Think of it like...

Imagine driving a car: a terminating error is like a sudden engine failure that forces you to stop immediately, while a non-terminating error is like a warning light that alerts you but lets you keep driving.

┌───────────────────────────────┐
│         PowerShell Script      │
└──────────────┬────────────────┘
               │
      ┌────────▼─────────┐
      │ Command Runs     │
      └────────┬─────────┘
               │
   ┌───────────┴────────────┐
   │                        │
┌──▼───┐                ┌───▼────┐
│No Err│                │Error   │
└──┬───┘                └───┬────┘
   │                        │
   │                ┌───────▼─────────┐
   │                │Error Type?      │
   │                └───────┬─────────┘
   │                        │
   │               ┌────────▼─────────┐
   │               │Terminating Error │
   │               └────────┬─────────┘
   │                        │
   │               ┌────────▼─────────┐
   │               │Script Stops      │
   │               └──────────────────┘
   │
   │               ┌────────▼─────────┐
   │               │Non-Terminating   │
   │               │Error             │
   │               └────────┬─────────┘
   │                        │
   │               ┌────────▼─────────┐
   │               │Script Continues  │
   │               └──────────────────┘

Build-Up - 7 Steps

1

Foundation

What is an error in PowerShell

Concept: Errors are messages that tell you something went wrong when running commands.

When you run a command in PowerShell, it might fail for many reasons like wrong input or missing files. PowerShell shows an error message to explain what happened. These messages help you understand and fix problems.

Result

You see an error message if something goes wrong during command execution.

Understanding that errors are feedback from PowerShell helps you realize they are not just failures but clues to fix your scripts.

2

Foundation

Two types of errors explained

Concept: PowerShell errors come in two types: terminating and non-terminating.

Terminating errors stop the script immediately. Non-terminating errors show a problem but let the script keep running. For example, if you try to get a file that doesn't exist, PowerShell might show a non-terminating error and continue. But if you try to run a command that is not recognized, it causes a terminating error and stops.

Result

Scripts behave differently depending on error type: stop or continue.

Knowing these two types helps you predict how your script will react to problems.

3

Intermediate

How to see error types in action

🤔Before reading on: do you think a missing file causes a terminating or non-terminating error? Commit to your answer.

Concept: You can test error types by running commands that fail in different ways.

Try this command to see a non-terminating error: Get-ChildItem -Path 'C:\NoSuchFolder' Try this to see a terminating error: Get-Item -Path 'C:\NoSuchFolder' -ErrorAction Stop The first command shows an error but continues. The second stops the script because of the -ErrorAction Stop parameter.

Result

You observe that some errors stop the script and others don't.

Seeing errors in action clarifies the difference and how to control script flow.

4

Intermediate

Using try/catch with terminating errors

🤔Before reading on: do you think try/catch can handle non-terminating errors by default? Commit to your answer.

Concept: try/catch blocks catch terminating errors to handle them gracefully.

Wrap commands that might fail in try/catch: try { Get-Item 'C:\NoSuchFolder' -ErrorAction Stop } catch { Write-Host "Caught error: $_" } This stops the script from crashing and lets you respond to the error.

Result

Script catches the error and runs catch block instead of stopping.

Understanding that try/catch only works with terminating errors helps you write better error handling.

5

Intermediate

Converting non-terminating errors to terminating

🤔Before reading on: do you think you can make non-terminating errors stop the script? Commit to your answer.

Concept: You can force non-terminating errors to become terminating using -ErrorAction Stop.

Many commands have an -ErrorAction parameter. Setting it to Stop makes non-terminating errors behave like terminating ones: Get-ChildItem 'C:\NoSuchFolder' -ErrorAction Stop This lets try/catch handle errors that normally wouldn't stop the script.

Result

Non-terminating errors now stop the script and can be caught.

Knowing how to convert error types gives you full control over error handling.

6

Advanced

Error variable and error stream usage

🤔Before reading on: do you think $Error variable holds only terminating errors? Commit to your answer.

Concept: PowerShell stores all errors in the automatic $Error variable and error stream, regardless of type.

The $Error variable is a list of recent errors, both terminating and non-terminating. You can inspect it to understand what went wrong: $Error[0] Also, errors are sent to the error stream, which you can redirect or capture for logging.

Result

You can review and manage errors after they occur.

Understanding error storage helps in debugging and logging errors effectively.

7

Expert

Impact of error handling on script performance and flow

🤔Before reading on: do you think forcing all errors to terminate is always best? Commit to your answer.

Concept: Forcing all errors to terminate can slow scripts and cause unwanted stops; selective handling is better.

Using -ErrorAction Stop everywhere can make scripts fragile and slow because they stop on minor issues. Experts selectively choose which errors to treat as terminating and use try/catch only where recovery is possible. They also use error streams and logging to monitor non-terminating errors without stopping the script.

Result

Scripts become more robust, efficient, and maintainable.

Knowing when to stop or continue on errors is key to professional script design.

Under the Hood

PowerShell commands write errors to an error stream. Non-terminating errors write messages but allow the pipeline to continue. Terminating errors throw exceptions that halt execution unless caught. The -ErrorAction parameter controls how errors are treated, and try/catch blocks handle exceptions by intercepting terminating errors. The $Error automatic variable collects all recent errors for inspection.

Why designed this way?

PowerShell was designed to be flexible for automation. Allowing non-terminating errors lets scripts continue working even if some parts fail, which is useful in batch operations. Terminating errors exist to stop scripts when continuing would cause bigger problems. This balance helps users control script behavior precisely.

┌───────────────┐
│ PowerShell Cmd│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Error Occurs? │
└──────┬────────┘
       │Yes
       ▼
┌───────────────┐          ┌─────────────────────┐
│ Check -ErrorAction│─────▶│ If Stop: Throw Exception│
└──────┬────────┘          └──────────┬──────────┘
       │No                          │
       ▼                           ▼
┌───────────────┐          ┌─────────────────────┐
│ Write to Error │          │ Exception Halts     │
│ Stream        │          │ Script (Terminating) │
└──────┬────────┘          └─────────────────────┘
       │
       ▼
┌───────────────┐
│ Script Continues│
│ (Non-Terminating)│
└─────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think try/catch handles all errors by default? Commit to yes or no.

Common Belief: Try/catch blocks catch every error automatically.

Reality: Try/catch only catches terminating errors unless non-terminating errors are converted with -ErrorAction Stop.

Why it matters: Assuming try/catch catches all errors leads to unhandled errors and script crashes.

Quick: Do you think non-terminating errors stop the script? Commit to yes or no.

Common Belief: Non-terminating errors stop the script just like terminating errors.

Reality: Non-terminating errors only report problems but let the script continue running.

Why it matters: Misunderstanding this causes confusion about why scripts keep running despite errors.

Quick: Do you think all errors are stored in $Error variable? Commit to yes or no.

Common Belief: Only terminating errors are stored in the $Error variable.

Reality: Both terminating and non-terminating errors are stored in $Error for review.

Why it matters: Believing otherwise can cause missed opportunities to debug non-terminating errors.

Quick: Do you think forcing all errors to terminate is always best? Commit to yes or no.

Common Belief: Setting all errors to terminate makes scripts safer and better.

Reality: Forcing all errors to terminate can make scripts fragile and stop unnecessarily on minor issues.

Why it matters: Overusing terminating errors can reduce script reliability and performance.

Expert Zone

1

Some cmdlets emit non-terminating errors by design to allow batch processing without stopping on each failure.

2

The -ErrorVariable parameter lets you capture errors separately from $Error for fine-grained error management.

3

Using $PSDefaultParameterValues you can globally set -ErrorAction for cmdlets to control error behavior consistently.

When NOT to use

Avoid forcing all errors to terminate in large batch scripts where some failures are expected. Instead, use logging and conditional checks. For critical operations, use try/catch with terminating errors. Alternatives include using error streams and event logs for monitoring.

Production Patterns

Professionals use try/catch for critical commands, convert specific non-terminating errors to terminating, and log errors for later review. They also use -ErrorAction SilentlyContinue to ignore minor errors and $Error to audit script health.

Connections

Exception Handling in Programming

Builds-on

Understanding PowerShell errors connects directly to how exceptions work in other languages, helping you transfer error handling skills across tools.

Fault Tolerance in Systems Engineering

Same pattern

Terminating vs non-terminating errors mirror fault tolerance concepts where some failures stop systems and others are tolerated to keep running.

Traffic Signal Systems

Analogy in control flow

Just like traffic lights control flow by stopping or allowing cars, error types control script flow by stopping or continuing execution.

Common Pitfalls

#1 Expecting try/catch to catch non-terminating errors without conversion.

Wrong approach:

try {
Get-ChildItem 'C:\NoSuchFolder'
} catch {
Write-Host "Caught error"
}

Correct approach:

try {
Get-ChildItem 'C:\NoSuchFolder' -ErrorAction Stop
} catch {
Write-Host "Caught error"
}

Root cause:

Misunderstanding that try/catch only catches terminating errors by default.

#2 Setting -ErrorAction Stop on all commands indiscriminately.

Wrong approach:

Get-ChildItem 'C:\Folder1' -ErrorAction Stop
Get-ChildItem 'C:\Folder2' -ErrorAction Stop
Get-ChildItem 'C:\Folder3' -ErrorAction Stop

Correct approach:

Get-ChildItem 'C:\Folder1'
Get-ChildItem 'C:\Folder2' -ErrorAction Stop
Get-ChildItem 'C:\Folder3'

Root cause:

Not recognizing that forcing all errors to terminate can cause unnecessary script stops.

#3 Ignoring the $Error variable and missing error details.

Wrong approach:

Write-Host "Script ran" # No error checking

Correct approach:

if ($Error.Count -gt 0) { Write-Host "Last error: $($Error[0])" }

Root cause:

Not knowing that $Error holds all recent errors for inspection.

Key Takeaways

PowerShell errors come in two types: terminating errors stop scripts immediately, non-terminating errors report problems but let scripts continue.

Try/catch blocks only handle terminating errors unless non-terminating errors are converted using -ErrorAction Stop.

The $Error variable stores all recent errors, helping you review and debug issues after they happen.

Forcing all errors to terminate can make scripts fragile; selective error handling leads to more robust automation.

Understanding error types and handling controls script flow and reliability in PowerShell scripting.