Generic filters
Exact matches only
Filter by Custom Post Type

Is this list "Everything" in PowerShell?

Aug 6, 2013

Soooo.... it's time for me to start looking at updating my various training materials (books, videos, courses, whatnot) for v4.

I'm going to, with at least some of these, take an all-versions approach. I'll teach what's in v2, then cover what v3 added, then cover v4, etc. It'll be easier to maintain over the upcoming years.

For right now, I'm trying to assemble an organized topic list of "everything" the shell does. Now, I need to wrap that in an important caveat: I'm aiming at admins. Not developers. I'm not saying devs aren't a great audience, but for this project I need to constrain my scope to just the admin audience. I'm also focused mainly on what the shell does natively, with only a few diversions into external or underlying technologies. Those are fixed caveats for this project - no exceptions.

Right now I"m kind of chunking the list into what I feel can be taught (by me) in 20-30 minutes, or a book chapter, or something like that. This isn't necessarily how the material will be presented - this is just me organizing my thoughts so as to not miss important stuff.

So, given the list below, what do you feel is missing?

(Numbers are major topics; letters are basically my mental notes about what the topic might include that I might otherwise forget; like I said, this isn't meant to be a real book outline - it's just a topic list)

PowerShell Core
1. Series Introduction and Lab Setup
2. Windows PowerShell Introduction and Requirements
3. Finding and Discovering Commands
a. Importing modules and snapins
4. Interpreting Command Help
5. Running Commands
6. Running External Commands: Tips and Tricks
a. $Lastexitcode
7. Working with PSProviders and PSDrives
8. Variables, Strings, Hashtables, and Core Operators
a. Double quote tricks, subexpressions
b. Here-strings
c. Escapes
d. Variable types
e. Arrays
f. Math operators
9. Regular Expression Basics
a. Basic regex language
b. –Match
c. Select-String
10. Learning the Pipeline: Exporting and Converting Data
11. Understanding Objects in PowerShell
12. Core Commands: Selecting, Sorting, Meauring, and More
13. How the PowerShell Pipeline Works
14. Formatting Command Output
15. Comparison Operators and Filtering
16. Advanced Operators
17. Setting Default Values for Command Parameters
18. Enumerating Objects in the Pipeline
a. Working with object methods
19. Advanced Date and String Manipulation
20. Soup to Nuts: Completing a New Task

PowerShell Remoting
21. PowerShell Remoting Basics
22. Persistent Remoting: PSSessions
23. Implicit Remoting: Using Commands on Another Computer
24. Advanced Remoting: Passing Data and Working with Output
25. Advanced Remoting: Crossing Domain Boundaries
26. Advanced Remoting: Custom Session Configurations
27. Web Remoting: PowerShell Web Access

28. WMI and CIM: WMI, Docs, and the Repository
29. WMI and CIM: Using WMI to Commands Query Data
30. WMI and CIM: Using CIM Commands to Query Data
31. WMI and CIM: Filtering and WMI Query Language
32. WMI and CIM: Associations
33. WMI and CIM: Working with CIM Sessions
34. WMI and CIM: Executing Instance Methods

35. Background Job Basics: Local, WMI, and Remoting Jobs
36. Scheduled Background Jobs

Scripting in PowerShell
37. PowerShell Script Security
38. Prompting for Input, Producing Output
39. Creating Basic Parameterized Scripts
40. PowerShell Scripting: Logical Constructs
41. PowerShell Scripting: Looping Constructs
a. Break and Continue
42. PowerShell Scripting: Basic Functions, Filters, and Pipeline Functions
43. PowerShell Scripting: Best Practices
a. Line breaking
b. Splatting
c. Formatting
d. Source Control
e. Etc.
44. PowerShell Scripting: From Command to Script to Function to Module
45. PowerShell Scripting: Scope
46. PowerShell Scripting: Combining Data from Multiple Sources
a. Ordered hashtables

Advanced Functions (“Script Cmdlets”)
47. Advanced Functions: Adding Help
48. Advanced Functions: Parameter Attributes
49. Advanced Functions: Pipeline Input
50. Advanced Functions: Parameter Sets

Advanced Scripting Techniques
51. Creating Private Utility Functions and Preference Variables
52. Adding Error Capturing and Handling to a Function
53. Advanced Error Handling
a. Variety of error capturing options
b. Catching multiple exceptions
c. Etc.
54. Error Handling the Old Way: Trap
55. Debugging Techniques
56. Creating Custom Formatting Views
57. Creating Custom Type Extensions
58. Working with SQL Server (and other) Databases
59. Working with XML Data Files
60. Supporting –WhatIf and –Confirm in Functions
61. Troubleshooting and Tracing the Pipeline
62. Using Object Hierarchies for Complex Output
63. Creating a Proxy Function

PowerShell in the Field
64. From the Field: Enhanced HTML Reporting
65. From the Field: Trend Analysis Reporting
66. From the Field: Scraping HTML Pages

PowerShell Workflow
67. Introduction to PowerShell Workflow

Desired State Configuration
68. Desired State Configuration: The Basics
69. Desired State Configuration: Configuration Scripts
70. Desired State Configuration: Writing Resources
71. Globalizing a Function or Script
72. Discovering and Using COM Objects
73. Discovering and Using .NET Classes and Instances

Writing Scripts for Other People
74. Controller Scripts: Automating Business Processes
75. Controller Scripts: A Menu of Tools
76. Creating a GUI Tool: The GUI
77. Creating a GUI Tool: The Code
78. Creating a GUI Tool: The Output
79. Creating a GUI Tool: Using Data Tables

Advanced Core Techniques, Tricks, and Tips
80. Using Type Accelerators
a. [ADSI]
b. [XML]
c. [VOID]
d. where they’re documented
81. The Big Gotchas in PowerShell
a. (from the ebook list)
82. Fun with Profiles
a. Profiles and hosts
b. Prompt
c. Colors
d. Get a credential
83. Random Tips and Tricks
a. Redirection changing pipelines
b. $$
c. $?
d. Dot sourcing

Recommend0 recommendationsPublished in Training

  1. It's fairly complete, I've struggled to find something that wasn;t there. The only thing am missing is executing command line tools and do something with the output. Or in general calling other elements outside the shell.

  2. That's a really good list. I didn't see PowerShell Web Access, but it might fall into one of the remoting topics.

    • PWA is technically an OS feature, not a PowerShell thing, which is why I wasn't covering it in that list. E.g., PWA comes with the server OS, not with WMF. But I might add it anyway, and the Remoting section isn't a bad place to put it since it relies on Remoting as a pre-req.

  3. You may have these within each topic, but how about 4a - updating the help (especially when the server has no Internet access

    As an admin with no scripting background i would find an overview of how to use loops, etc (for example get a list of server names and on each server do something)

    The only other thing would be to include a PowerShell gotchas that you have already compiled as I have found that useful as well.

  4. I'd like to see some reference to how to access other .net libraries from Powershell. Also how database access is supported (odbc, adonet, etc.)

  5. If this list is the start of a new book, i'm buying it DAY ONE !!

    • It isn't, necessarily. Think of it as a "unified objective domain." Frankly, most of this is already covered pretty thoroughly in "PowerShell In Depth," so at most I'd work with my co-authors to expand that book in its next edition. This list is, however, definitely driving what I do in my next CBT Nuggets video series. If you take each item on the list as a ~20min video nugget, you're looking at 26+ hours so far, I think.

  6. Here Strings ( I see a lot of string concatenation that isn't really necessary )

    Documenting/Commenting in functions and scripts

  7. Some I'd add:

    - PowerShell profiles
    - Doing math in the shell
    - Automatic variables (Like $$, $?, $LastExitCode etc), can be added under number 8 I think.
    - Dot sourcing

    • Many thanks! Some of those are so random I'm thinking of a "Random Tips and Tricks" item. #8 is really about some core stuff I NEED you to know before I go any further; you'll notice that the material is more or less sequenced so you learn pre-reqs before needing them. I'm gonna do a heading on profiles, too - that's a good place to cover stuff you'd DO in a profile, like prompting for a credential to re-use later, or setting colors, or changing the prompt, and stuff. All good ideas.

  8. It's a minor thing, but I'd suggest moving #6 (external commands) after the section on strings. If you're not using the --% operator (in v3+), there are some gotchas with making sure PowerShell special characters get quoted or escaped properly in the external commands, which would build well on the strings material.

  9. Are you saying Powershell V4 is coming out now? What will be the major difference from V3?

    • I'm pretty clearly not saying that, no, but we know v4 will ship with Win2012R2, and MS has said that will be "later this year." DSC is the major difference, and I've blogged about that here already.

  10. In the Scripting or perhaps the Debugging sections, I'd like to see something like: Taking a script from your desktop and getting it ready for the next level... deploying it across your Enterprise. Basically how do you take a working script and make it usable company-wide. For example: What kinds of things should an Admin using PowerShell consider adding to some code to take it to the next level (as it were)? What kind of debugging should be added? How about adding in error logging to track the systems where the command did not work (but set it up to continue hitting additional devices where the commands do work)? When and how to hit hundreds of systems at a time versus one-by-one? Of, and should you try that last with 2000 remote devices all at once or perhaps set it up to hit, say, 100 at a time and then move to the next batch? And what the heck would the code look like for that?

    • Excellent thoughts. Thing is, I tend to teach with the assumption that everything will be deployed like that - so the stuff you're talking about is more or less all the video series will cover. I know some folks have a different approach when they're doing stuff "for themselves," but I've personally never coded that way, and I find it easier to code 'as if I mean it' from the outset. That way there's no need to spend time on the next level. So hopefully you'll get what you're after right from the get-go!

Skip to toolbar