The future of tech skills training: Like an open book test

Skills development and training is a huge part of driving an organisation forward into the future, and so it’s something that I spend a lot of time and energy on. I’ve seen a bunch of stuff over the past year that leads me to expect a revolution in training when it comes to mastery of a topic.

Katacoda

I first came across Katacoda at RedMonk‘s Monkigras conference a couple of years ago when Luke Marsden showed me the Weave.works Tutorials he’d been building. I immediately fell in love with the openness and interactivity of the platform. I’d seen training that simulated a real world environment before, but nothing that provided an authentic on-demand experience. For me the best demo of Katacoda is the 10-minute beginner level ‘Get Started with Istio and Kubernetes‘ — there’s just so much packed into it.

I spent the following months creating what became our ‘DevOps Dojo White Belt,’ by taking the ‘Infrastructure as Code Boot Camp’ materials we had used for in-person workshops and making them into something that could scale better. At the time of writing, over 10,000 DXCers have earned this White Belt.

It was much more recently that I saw the full potential of Katacoda realised. The team that created our ‘DevOps Dojo Yellow Belt’ training incorporated Continuous Integration and Continuous Delivery (CI/CD) pipelines in such a way that we could test whether students were achieving specific outcomes.

Qwiklabs

After attending a Google Cloud Derby hosted by Ant Stanley under the auspices of the London Serverless Meetup, I was sent an invite to some Google Cloud Platform (GCP) training on the Qwiklabs platform (recently acquired by Google).

Specifically, I was invited to do the GCP Architecture Challenge, which turned out to be like no training I’d ever done before. As explained in the ‘quest’ intro: ‘Challenge Labs do not provide the “cookbook” steps, but require solutions to be built with minimal guidance…All labs have activity tracking and in order to earn this badge you must score 100% in each lab.’

I found it was like doing an escape room. Each lab would describe an outcome that needed to be achieved, and it was up to me to figure out how to do that (using the tools provided), against the clock. Perhaps I should have done some training first, but it was really fun to learn stuff on the fly, solve the puzzle, and escape from the room lab before the clock ran down.

Exercism

I saw this outcome-oriented theme continue when a colleague pointed me towards Exercism recently. It provides training for a wide variety of programming (and scripting) languages with a common underpinning that it’s all based on tests. Just like with test-driven development (TDD), you write code to pass the test suite. This results in a stunning variety of working results that can be seen from other people’s submissions, which are worth reviewing to discover everything from language idioms to significant performance improvements. Students can edit the tests too, adding things that might have been missed. It’s a really neat way of learning a language and at the same time getting into the discipline of TDD.

Codecademy, Microsoft Learn and The Hard Way

I can’t finish without a nod to these two platforms.

I started using Codecademy when it first launched and I put up with the early wrinkles because it was so beautifully immersive. I was lured back recently by their Learn Vue.js course after seeing Sarah Drasner showing off its potential in her Serverless Days London talk. It was great (the course and Vue.js) — though I can’t say I’m keen on the cost of their ‘Pro’ subscription model. I can’t find a recording of Drasner’s talk, but her VueConf.US talk ‘Serverless Functions and Vue.js‘ seems pretty similar.

I didn’t attend Microsoft’s Ignite event in person, but it seems to me that Learn was by far the most important thing that came out of the 2018 event. I was seriously impressed at how well they’ve incorporated on-demand subscriptions for the underlying Azure services it provides training for. There’s some seriously good introductory material there, and I hope over time they’ll close the gap to meet up with Azure certifications.

The Hard Way isn’t so much a platform as a methodology designed to get ‘muscle memory’ into students, and show them the essential details that often get buried under layers of abstraction (but matter when things fall apart). I first came across it with Kelsey Hightower’s Kubernetes The Hard Way, and got pulled deeper with Ian Miell’s Learn Git/Bash/Terraform The Hard Way, though it’s worth noting that it all started with Zed A. Shaw.

What do I mean by mastery?

A discussion thread following my initial post asked if ‘cookbook’ style training was sufficient for many cases, and this led to me needing to clarify between training that we do to achieve familiarity, and training that we do to achieve mastery.

Familiarity if often good enough. Not everybody needs to be able to craft a new CD pipeline; it’s good enough that they know what CD is and does. Not everybody needs to be a compliance expert; it’s good enough that we know what a breach looks like and how to report it.

So familiarity is sufficient for many training use cases, and ‘cookbook’ training is good enough to get us there. But to truly wield the power of the tools at our disposal we need mastery, and mastery in the past has come from hard won (and expensive) miles on the experience clock. The revolution we’re seeing unfold is a way to accelerate that process in the safety of training environments.

The future: Interactive and outcome-oriented

The future of IT training is interactive and outcome-oriented. Rather than being spoon fed a particular way to do something, we can expect to be given open platforms that allow for safe experimentation and open challenges that test our ability to solve problems with the entire resources of the Internet at our fingertips (just like when we’re putting knowledge to use at work).

The emergent point here is that in achieving mastery students shouldn’t be spoon fed every minute detail. We should expect them to go and read the docs, dive into Stack Overflow, search for answers on Google and in GitHub, and maybe even watch some YouTube primers. Real life is an open book test, so training should reflect that.

If we want people to use TDD and build CD pipelines, then it should be no surprise that those same tests and pipelines can form an essential part of their skills development. The good part is that this unleashes unlimited creativity, because people can figure out their own way to achieve an outcome; approaches can be compared with peers and mentors to discover how things might be improved. It’s a long way from passively sitting in a classroom or watching a video.

This post first appeared in Chris Swan’s blog.


Chris Swan headshotChris Swan is a DXC Fellow and vice president and chief technology officer for the Global Delivery organization at DXC Technology, where he leads the shift towards design for operations across the offerings families, and the use of data to drive optimization of customer transformation and service fulfillment. He was previously CTO for Global Infrastructure Services and general manager for x86 and Distributed Compute at CSC. Before that he held CTO and director of R&D roles at Cohesive Networks, UBS, Capital SCF and Credit Suisse, where he worked on app servers, compute grids, security, mobile, cloud, networking and containers. See Chris’s blog and his observations in InfoQ. @cpswan

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

%d bloggers like this: