When I wrote Microsoft course 10325A, their original 5-day Windows PowerShell course, I saved variables until Module 11. My thought at the time was to focus on teaching just what students needed for what they were about to do - and no more. "Just in time learning" can be effective, because it lets you immediately experiment with whatever you've just learned, and helps minimize the need to store up concepts for later use. I'd also had a lot of class experiences where bringing up variables too soon engaged a defensive mechanism in some students: "I'm not a programmer, variables are programming, and I'm shutting down right now."
The biggest piece of MCT feedback from 10325A was, "don't do that." Trainers told me they were often teaching module 11 much sooner. Jeff Hicks had what I think is the best explanation for why: Without variables, you're locked into the one-liner approach in PowerShell. While one-liners are neat, and effective, they aren't always easy to read or to mentally de-construct. Using variables earlier in the course, Jeff argued, let you break things down into smaller logical chunks.
Now, one thing I've had to accept in writing 10961A is that I can't please everyone. The feedback on 10325A is incredibly contradictory. Some MCTs want more programming, others want none at all. Some want classes to run 9am-4pm; others want 8am-6pm. Some want less content on the slides (actually, most wanted that). So what I decided to do is try and provide the material to accommodate what it felt like everyone was asking for, and rely on MCT's ability to mix things up as needed for their classes.
(As an aside, I do think some MCTs jump into the "programming" aspect of PowerShell too quickly. It's fine if you've got a room of people with programming experience, but it keeps students from learning some valuable fundamentals and turns the class into a "scripting" class awfully quickly. I'm not sure every MCT has done a really thorough cognitive analysis of their class results to determine if the programming-first approach is best; my experience with Month of Lunches readers suggest it isn't.)
But I still didn't want to do the full deep-dive on variables super-early in the course. So here's what I think I'm doing: early in the course, you'll be exposed to variables, in a very simplistic sense. They're described as a named place to store objects, and used to de-construct a complex one-liner into a multi-line series of logical steps. Early in the course, I don't go into naming rules, the double quotes tricks, or anything else. You learn exactly enough about variables for the task at hand - and no more.
In module 7, which is right before the module where you turn a command-line into a parameterized script, I cover variables more formally. I cover their rules, usage, double quotes, all that stuff. So you learn a wee bit about variables early, and then learn the full details later - just before you need to use variables more seriously in a script. So, keeping with the just-in-time learning.
The variables material is broken out into its own lesson in module 7, so an MCT hell-bent on teaching everything about variables right up-front can do so.While the feedback from 10325A suggests that MCTs think every course should be designed for the way they teach, I'm not sure they all realize how differently they all teach. The best I can do is provide the material in standalone chunks that MCTs can rearrange as needed. After all, the whole point of having a live instructor, as opposed to a recording, is the instructor's ability to teach to your specific needs. So MCTs will have to be happy rearranging the material a bit as-needed; my outline is the recommnded approach that will work best across the broadest array of students, but it isn't perfect for everyone. Nothing could be.
As a point of reference, 10961A doesn't dive into scripting as deeply as 10325A did. PowerShell 3.0 has enough new, extra stuff that a 5-day course doesn't allow for deep programming topics. You do take a command and walk it through to being a script module, so you see the range of scripting options, but you don't practice them in depth. It's inch-deep, mile-wide coverage of scripting, as opposed to something deeper and more focused. I'm hoping Microsoft can find budget for a full-on "scripting/toolmaking" class in the future, but 10961A ain't it.
So... what do you think of this approach?