Teaching .Net–my role as Teacher

Earlier this year, I started practicing some affirmations.   They were along the lines of “There is opportunity everywhere”, and “I do not know myself.”  The intention was that if there’s some way that I could be growing, that the Universe will guide me to it.

There are so many subtle (and possibly not-so-subtle) things that have changed for me since then.  Or, rather, I haven’t changed – I’ve always been me – but I’ve discovered new modes in which I am comfortable.

One of these is regarding my role as a teacher.   There’s a long story arc – it probably starts at helping new wizards to code LPC on a Mud in 1991, stops by at creating training materials for Perl at a startup in 1997, touches on creating Unit Testing and Integration Testing video lessons for a company in 2009.   This latest leg of the story involves:

• Assisting (briefly) with being a mentor for Code Louisville, and being sad that there was not a .Net curriculum, and attempting to design one;
• Being considered by a company to be a lead .Net instructor at a bootcamp that’s coming to Louisville. 
• Having a serious chat with a dude who knows how to teach teachers; getting introduced to Madeline Hunter’s “Mastery Teaching”. To be honest, only got through the first 4 chapters or so, but wow.   (Note: link to the book I COULD have gotten; I got an older and much more bare-bones book).
• Being asked to help a guy with learning IoT specifically.  I got paid in Qdoba and Starbucks.  Turns out he knew it already, didn’t know that he knew it.  THAT’S ALL?  I giggled and continued eating my burrito, and then we talked about bunches of other stuff.
• And today, helping a person start to crash-learn .Net.   No, Double-A, I did not Video, so I guess it didn’t happen.

How did it Go?

I had designed a curriculum; given the learner is an experienced programmer, I was hoping that we’d be able to blaze through the material.   However, ‘twas not so.   We blazed, yes; but being a .Net programmer for 15 years, there are so many things I take for granted that we ended up discussing.  For example:

• Assemblies vs File boundaries vs Namespaces  (did you know ildasm.exe not on disk anymore automatically? when did they change that? A little harder to get a visual on things now)
• Solutions vs Projects and why oh my?
• bin vs obj
• PDB files
• rearranging the Visual Studio panes and tabs and “Reset Window Layout”
• Keyboard shortcuts (for somebody used to vi, it’s a learning experience!)
• GAC references vs project references; when does the public key token come into play?  (and then, also, NuGet)
• Appropriate .gitignore files, no, you don’t need to save the packages/ directory
• int vs System.Int vs boxing vs DateTime vs String, and how that plays out with ref & out; when is it a pointer or not?
• .Net framework versions
• Garbage Collector internals, as compared to other languages; generational collection; finalization.
• Assembly version mappings, the new DLL hell.  (We never talked about DLL hell)
• Stream vs StreamWriter vs TextWriter and the amazingnessballs of System.Io
• Reflection, typeof(), GetType(), serialization
• String.Compare(,,true) vs StringComparison.InvariantCultureIgoreCase, and culture, and evolution of the .Net framework.

So in 4 hours, we got a good amount done – enough to get them dangerous – a console app that kept track of a todo list and persisted between runs.   I hope it got him to a spot where he could investigate MVC on his own.  I also pointed him at Pluralsight, and we’re going to follow up via email for the rest of this week.     Btw, Pluralsight is the densest stuff I’ve seen; second runner up is Lynda, then we start talking Microsoft Virtual Academy.  

How did it map to Mastery Teaching?

As a thought experiment to myself, I am attempting the mapping.  How did I do?  How could I improve?

1.  Content, Behavior of Learner, Behavior of Teacher

I think the layering of content worked fairly well.  For example, used int.TryParse() to introduce out parameters, and String.Format() to introduce “params”.   A little slow at times; but we kept improving a program, which gave a nice feedback cycle for success.

Learner and Teacher behaved mostly well.    There was no dancing in chicken-suits.

2. Level of Concern, Feeling Tone, Success.

Already talked about success.  The ongoing concern mapping was to take a known body of information (“how to program in Go and PHP”) and to map the concepts to .Net.    Feeling Tone was ongoing successes, was pretty good, though after about 3.5 hours, definite brain depletion.

3. Interest, Knowledge of Results, Intrinsic/Extrinsic

By keeping the functionality of the program we were working on as a dangling carrot, interest stayed high.  The way we worked it is, I would write some code on my laptop demonstrating something, then he would write similar (sometimes the same) code on his laptop, trying to achieve the same result.  On the way, there were fun little learning things (keyboard shortcuts, debugging, inner exception drilldowns, etc) that kept the learner’s implementation “fresh” rather than a copy – when it worked, they KNEW how they got it to work.     All the motivation was Intrinsic.

4. Review, Anticipatory Set, Objective

I had the curriculum broken out into sections.  For example: “Hello World” followed by “console app in a while loop accepting commands from user”.   I think I could have done a better job bookmarking the sections, and doing the anticipatory set.  I didn’t bother with Review because we were both firing on top cylinders.. or .. maybe I did.  After we did a block, I’d go back to the curriculum and see if we had covered all the topics for that round.     And the end of each block, there was a definite objective – “having a working program that does X, where X is useful in a geek evolution way”.

5. Basic Info / Organization, Simplest form, Modeling.

Each module introduced a very small set of new things.  Some chunks were larger than others, for example:  using(), IDisposable, System.Io.StreamWriter, Xml Serialization, gettype() all went together – I couldn’t think of a meaningful way to make that smaller.   

Because we started from a console app, we were able to hit concepts in small buildable chunks.  For example, int.Parse() => exception => try/catch to deal with exception => int.TryParse => out parameters.   We evolved the code and ran it each time, enjoying the error messages given.

I did NOT want the first .Net code they saw to be a Controller + View + Entity Framework.  (Except they ran ahead and created a project as such already.  Holy crap that’s a lot of firehose)

That’s as far as I’ve really gotten through the Mastery Teaching stuff;  And that’s pages 1-38 of that book.  Pretty crazy, huh?    This is some good Shizzle.

Finishing the rest of the book is still on my list; however, its one of those where you read a chapter – and only a chapter – and then it has to stew in your head for a weekend.  So, it will be a little bit.

In Conclusion

I did not choose to become a full-time instructor.  I’m sad about that… it has to do with schedule and availability-of-free-time and mobility than it does about whether I like it or not.  I love organization of information and teaching somebody who wants to learn.

But, hey, maybe I can do this one-on-one kind of tutoring instead.  

And if there’s demand for it, maybe I’ll make some spending money at it too.      (Relax, U.S. – using you as a guinea pig to prove out my curriculum.  Thank you.)

Future Tweaks

• I  think I’d have to budget about 3 hours for .Net basics, 3 hours for MVC/web, and 2 hours for EF?  Oh, another 1 hour for SqlCommand.  This is paired-time.
• I’m not sure if the loading could/should be “watch pluralsight first then we code together” or “code together then watch pluralsight then write your own” or what.      I think there’s definitely “parrot the instructor but you type it yourself and enjoy it yourself” and then “do the same thing on your own project.” steps that could be played as well.  (At no point will I touch the learner’s keyboard/mouse – everything they do is by their own typing).
• I think a limit of 1-2 hours per day of active instruction time seems right, to give brain-sink-rearranging time to gel.

Super Excited. Feeling Mighty. 

Anybody else want to be my guinea pig, see if I can fine-tune my .Net tutoring / teaching skills?   I think 1 more test subject before I would start charging.   

Note to self:  him vs they – I kept switching.  I’ve spent 30 minutes or more on this post, so I need to post it and move on.    Kitten just tried to walk across keyboard.