All Episodes

A brief outline of this series, along with information on setting up your own PowerShell lab environment. You'll also find URLs for the series' online companion content and other useful learning resources.

Get some of the first PowerShell "gotchas" out of the way, decide which experience you'll use to access PowerShell, and learn about some of the most common initial points of confusion.

The single most important PowerShell skill is being able to use its help system, and you'll learn all of the tricks, ins, and outs for doing so.

Start getting used to PowerShell's syntax and terminology, and learn a variety of ways to run both internal and external commands.

PowerShell's system of providers is an important part of the shell's extensibility and management approach - and too few classes spend any time teaching you this critical technology! Learn everything there is to know about providers and how to use them in a variety of situations.

Learn how PowerShell's pipeline, when properly used, can often eliminate the need for long, complex scripts. Focus on importing and exporting data, converting data to different output forms, and more.

PowerShell was designed for extensibility, and the ability to add commands is what lets it connect to, and manage, so many different technologies. Learn how this works, and how to discover for yourself what commands you have to work with.

You need to get in-sync with some PowerShell terminology in order to continue, as well as learn some tricks for letting PowerShell teach you about the data it knows how to work with.

Mastering the PowerShell pipeline is the best way to become a shell expert. Learn how data is passed between commands, and how you can manipulate that process to achieve your administrative goals.

Learn to take the output of any PowerShell command and create beautiful (well, good) looking output for the screen, printer, or text file - and learn the "gotchas" that trip people up the most!

Learn to focus on exactly the data you want to see by filtering it right within the pipeline.

Learn the basics of PowerShell's incredible Remoting, the technology that makes managing a hundred servers as easy as managing just one.

Learn about WMI - and its new cousin, CIM - and how they provide access to a wealth of management information through PowerShell.

Get PowerShell to do several things at once using its integrated jobs mechanism. You'll learn about many types of jobs, including scheduled and WMI jobs, to give you maximum flexibility and functionality.

PowerShell is all about batch management - doing something to several targets in just one action. Sometimes that means having PowerShell repeat some task over and over against a bunch of targets - and you'll learn how to do that.

This short Nugget will focus on PowerShell's security system for scripting, including recommendations and under-the-hood details of how it all works.

As you start doing more with PowerShell, you'll need to become familiar with variables, a way of temporarily storing data in-memory and re-using it in numerous ways.

You'll often need to write scripts that interact with human beings, and PowerShell offers a few ways to do that. Not all of them are good, though - so you'll learn what to do, and when, and how to stick with the "PowerShell way" to get maximum reusability from your creations.

Learn how to create persistent, reusable Remoting connections, store them in variables, and manage them.

Start with a command and turn it into a parameterized, reusable script that can be easily distributed to, and used by, your less-technical colleagues.

Take your scripts to the next level by adding mandatory parameters, validating input, adding verbose output, and more.

A roundup of additional things you'll find useful, including profiles, more operators, string and date manipulation, and more.

A quick look at what will be covered in this series, along with a brief overview of system requirements.

Learn about PowerShell's five main scripting constructs for logic and loops, and briefly review some of the biggest "gotchas" around PowerShell variables. Remember that Don's "PowerShell Foundations" series is a prerequisite to this series; you'll get the basics about variables in that other series.

Take a straightforward PowerShell command and evolve it into a script... a parameterized script... and a simple PowerShell function, all serving as the basis for more complex and powerful tools. Learn to output objects instead of text, add PowerShell-standard help to your new tool, and much more.

Tackle the sometimes-tricky and often-overlooked concept of scope in PowerShell scripts and tools. Learn to avoid some of the most common scope mistakes, how to observe best practices around scope management, and how to recognize some of the crazier stuff that you'll run across "in the wild."

Learn the best practices around PowerShell tool design - and actually SEE why those ARE the BEST practices! Don demonstrates how best practices can save you time, and how poorer approaches can actually make for more work, and for less flexibility, in the long run.

Combine your new knowledge of scope and tool design with the tool you've been building so far, and create an amazing Advanced Function - also known as a "script cmdlet." You'll learn how PowerShell can help with things like parameter validation, how to handle pipeline input, and much more, along with tips for writing tools more quickly and easily using PowerShell's native tool set.

Polish up your PowerShell tools by adding verbose output (for those "warm and fuzzies"), warnings, and even progress bars - all following standard PowerShell patterns and using native PowerShell capabilities. This Nugget also emphasizes the desirability of working "the way PowerShell wants you to" so that your work can enjoy maximum flexibility and compatibility.

Take everything you've learned to this point in Toolmaking and put it to use. You'll be introduced to a module that's designed to make HTML-based report creation easier and more natural, and see solid examples of how proper PowerShell design can speed development and maximize re-use of your hard work. Plus, you'll gain the ability to produce awesome, interactive HTML reports right within your own environment!

Learn the right way to anticipate, trap, and handle errors in your PowerShell scripts and tools. You'll learn techniques applicable both to PowerShell commands and to other functionality (such as executing methods). Don also shows you the old v1 "trap" technique, so that you can understand it when you run across it in older scripts. You'll be catching, logging, and dealing with errors in no time!

Get a real-world look at PowerShell script debugging, as Don walks you through an actual debugging scenario. You'll also learn tips and techniques for avoiding simple bugs like syntax errors, and learn about PowerShell's native tools for debugging your scripts. Above all, Don shares his tried-and-true (and terribly un-fancy) approach to debugging, guaranteeing that you'll never again need to bash your head against the wall in frustration!

Fed up with PowerShell's half-hearted attempts at formatting your script and tool output? Frustrated that Don keeps telling you to NOT bother formatting your output for a prettier display? Fret no more, because in this Nugget you'll learn how to PROPERLY create awesome-looking default formatting for your output, without compromising its ability to be piped to other PowerShell commands.

Your tools are starting to involve multiple files - the main script, formatting XML views, and more - and it's getting tough to keep all the right files in all the right places and to have everything load and unload together. It's time to put everything into a module, a single unit that can be distributed, loaded, unloaded, discovered, and maintained.

Ready to start working with databases? Using the free SQL Server Express as an example, Don extends the tool he's been building to query computer names from a database, grab system information from those computers, and then save that system information back to the database. You'll even be introduced to a free PowerShell module that makes database work a bit easier!

The tool we've made to this point just retrieves information, but eventually you'll start writing tools that change the system in some way. When you do, it's smart to follow PowerShell's standard pattern of supporting the -WhatIf and -Confirm parameters, so in this Nugget, Don will show you how. You'll also get some tips for easier code re-use, such as how to create and use PowerShell ISE snippets.