Micromaterials – Not Just For Language Anymore!

rebasing

As an exciting and not altogether unexpected twist…I’ve decided to start working on micromaterials for software development.

One of the most useful utilities in software development is a version control system called Git. The short version of what it does:

  1. Stores a snapshot of each version of the project, making it easy to revert to a previous version if something goes wrong.
  2. Allows people in different places to collaborate on shared projects

The second function is what I’m focusing on here, and one of the main tools used when collaborating across teams of developers is

git rebase

This is one of the most powerful features of Git, and when I first encountered it, it scared the &*!@ out of me. Horror stories abound across developer forums, nevermind the very vocal proponents using the same argument to come to the opposite conclusions of ALWAYS and NEVER using rebase…

At any rate, I just recently started using this command, and while I’m by no means a master at it, I’m very comfortable with it, use it almost every day, and it’s much less scary now.

The difference?

Practice. Literally just iterations of trying out the commands and seeing what happens.

This is obviously much more difficult if the first time you’re doing it is in a situation where you absolutely MUST get it right. A lower stakes context would make it much easier, and in fact that’s exactly what I’m targeting here.

Thankfully, the typical scenario for using this command is much less high-stakes than updating code in a live website…it’s just cleaning up the work you’ve done on a new feature before you submit it to be included in the wider project.

So by the argument of “familiarity breeds ease”, I thought this one particular activity would be a perfect candidate for a micromaterial.

The workflow goes like this:

  • Update your code iteratively, saving your work as you go
  • When the feature is finished, clean up all the extra noise (never let em see you sweat!)
  • Submit the cleaned up code (plus git version history) to be considered for integration into the main project.

Further, this is usually done in the command line, and so any authentic micromaterial should use this interface if possible. The activity I created is done completely inside the command line, and also aims to give immediate feedback to the learner. It also is a very simplified example that allows the learner to run through the commands in a predictable sequence.

At the end, the learners just run a command to check their work, and hopefully see a nice success message…

success

Advantages:

  • the activity happens entirely in the command line, just like usual rebasing
  • the activity isn’t an approximation of performing the command, it involves running the exact command we want to become more familiar with
  • the activity is very specific and targets one exact learning outcome
  • feedback on work is immediate and (mostly) unambiguous

Areas for improvement:

  • it targets one extremely small (though frequent) use case for this command
  • it doesn’t adequately address other means of removing the commit messages (no current handling of just dropping the commits themselves, rather than just the commit messages)
  • there’s currently no way to generate new data for the learner to work on…it’s only one activity, static, and manually created

…so then why do it?

Like my initial attempts at creating micromaterials for EFL, this is very much a proof of concept. I’m thinking of ways to use real project commit data (possibly from public github projects?), inject erroneous commit messages, and use those to practice rebasing.

There are difficulties moving much past this initial use case, however, since other common scenarios like needing to resolve merge conflicts during a rebase are a bit harder to manually create by altering project history.

This could be much more easily mocked in a separate application, but as the intent was to keep as close as possible to the authentic target learning context, I was aiming for having a pure git solution.

Though perhaps the ease of materials generation would outweigh the loss in authenticity?

At any rate, enjoying a bit of a different focus for now, and I guess we’ll see where this goes!

One thought on “Micromaterials – Not Just For Language Anymore!

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s