Pragmatic Learning at gSchool

In particular, it considers the first 3 weeks of curriculum in light of the Dreyfus Model of Skill Acquisition and how deliberate practice can be used to progress from one skill level to the next. These are covered in Chapter 2 of Pragmatic Thinking & Learning.

The Starting Point

The students that are accepted to gSchool have wildly different personalities, and wildly different learning styles.

Some people are delighted to dive into things they don’t understand, grip them with both hands, shake them hard until something interesting falls out, and then pick through the bits and pieces to see if anything goes together. Other students would much rather stand back and observe as other people break toys, figuring out from a distance which buttons and levers do what. Then, carefully and deliberately, they’ll pick up some pieces and spend an afternoon in a corner making sense of the world.

The students also enter the program with wildly different skill levels. Some students have never programmed before, and never seen a command line. Others have been programming for several years.

In terms of programming in Ruby they all fall into one of two categories on the Dreyfus scale: novices or advanced beginners.

Novices & Advanced Beginners

Novices and advanced beginners have a lot in common. They lack context. They’re not in their comfort zone. They do not understand enough to troubleshoot. Everything they do is going to require effort. Lots of it. The big picture doesn’t make sense to them, and doesn’t really feel relevant. Everything is disconnected, and they themselves feel disconnected from the skill they are developing.

It turns out, despite these commonalities, the care and feeding of novices is fundamentally different from that of an advanced beginner. A novice needs context-free rules and quick wins. An advanced beginner does not want to be spoon-fed the basics, but does not yet have enough context to be on their own.

During the first 3 weeks of gSchool we throw a number of tutorials and projects at the students, and it turns out that these are aimed squarely at the advanced beginner. No spoon-feeding in sight.

At first glance, we have failed our novices.

We have not provided them with any rapid successes, and we have left them in situations that are inherently confusing, with no instructions about how to make their way out of them. Some novices handle this with a great deal of optimism, whereas the lack of certainty and visible progress leaves others frustrated, discouraged, and despairing of ever getting it.

The Curriculum

We start with a tutorial called Ruby in 100 Minutes. It’s a good tutorial, and those who have programmed a bit before have no trouble understanding the concepts and completing it in 100 minutes.

I’ve noticed that the novices have gone back to it over and over again, but even after multiple trips through it, the concepts are still nebulous. They seem to understand it when they read it, but are unable to apply the concepts in practice. In other words: They’re not getting it.

Ruby in 100 Minutes is immediately followed by 3moretutorials that provide a guided tour of a variety of different concepts: File I/O, ERB templates, Arrays, Hashes, String manipulation, OAuth, 3rd party APIs, command line interfaces, reading and manipulating data from CSV files, and a whole host of other delightful things.

It’s a feast if you aren’t completely lost. Students who don’t have a grasp on the basics are left completely flummoxed. The novices go back to these tutorials over and over, perhaps hoping that maybe the logic of arrays, hashes, methods, and objects will click. It doesn’t. These tutorials are an exploration, they’re not intended to consolidate fundamental concepts.

After the guided tour of the universe, we serve up a project that builds on a handful of the ideas touched on in the tutorials. It centres on data in a CSV file, creating a ruby representation of that data, and performing searches on the resulting collection of objects. There is some string manipulation, and the project includes writing a command line interface.

This project is immediately followed by a second, much larger, project that is also based on CSV files, this time with far more data. The project includes managing a complex object graph and aggregating data held within that graph.

Overall, the advanced beginners fly through both of these projects. Some of the novices have a learning style that allows them to throw themselves into the fray and write all sorts of complicated nonsense. They muddle through and eventually some of the concepts sink in. Through a combination of sorcery, osmosis, and sheer luck they understand how methods call other methods, and what a block parameter is. Other novices spend most of their time beating their head against the wall getting nowhere, making little to no recognisable progress on the projects. Some made progress but felt that it was entirely due to blindly following along as someone else solved it along-side them.

Struggle is great, but too much of it is unproductive.

Curriculum, take 2

Pragmatic Thinking & Learning suggests that the way to advance from novice to advanced beginner is use exercises that provide context-free rules. The novice must not be put in a position where they don’t know where to go next, because they have no way of guessing, and don’t have the vocabulary to ask useful questions.

The exercises should provide inherent feedback so that the student can self-correct, and be repetitive so that the concepts have time to sink in. This sets the novices up for quick wins, and avoids the panic and excessive frustration that comes with being stuck.

Adjusting for Advanced Beginners

For the advanced beginners, not a lot would change. They might be given a few smaller preparatory exercises or more variations and extensions to keep them challenged and interested, but overall, the current curriculum is working really well for them.

Adjusting for Novices

For the novices, Ruby in 100 Minutes would be likely be followed by a large number of small exercises that cover many of the fundamental concepts introduced in that tutorial: string manipulation, variable assignment and scope, conditionals & branching, hashes, arrays, defining methods, sending messages to objects, using module mixins to inherit behaviour, looping, etc.

Given focused and effective exercises, novices are less likely to spend excessive amounts of time being stuck or doing work that is not constructive.

Focused Exercises

I’ve started working on a set of focused, repetitious exercises for enumerable methods, and the initial response from the novices in the group has been very promising.

This introduces a basic looping pattern using Enumerable#each to demonstrate that there’s no magic inherent in the enumerable methods. The first example is fully written out, giving the student an example to guide their efforts. The following exercises leave more and more to the imagination, and there are exercises to allow the pattern to sink in through repetition. The exercise is contained in a test suite, so there is a rapid feedback cycle built into it.

This pattern of having a very tight focus, using a test suite for feedback, and providing similar but not identical problems to solve can be expanded to introduce all of the concepts necessary to complete the first project: managing collections of objects, doing operations on those collections, building them from data in a CSV file, and writing a command line interface. With preparation like this I think that everyone in the group, advanced beginners and novices alike, would be able to tackle the project and complete it successfully in less than the time currently allotted to it.

Conclusion

The curriculum we have is an excellent starting point for the student who has mucked about with programming before, from the hardware hackers who have not done any scripting to the people who have cobbled together websites with gorilla glue, bailing wire, and PHP (no offence, PHP).

It is worthwhile to expand our curriculum to include a number of fundamental exercises that are tightly focused, repetitious, and contain inherent feedback in order to allow novices to experience quick wins and provide more opportunities to get a good grasp of basic concepts in Ruby.