In a previous article, I wrote of the value in developing your own experience in order to retain information. I wanted to see if this process could be streamlined even further, since a lot of the time in the workplace, we don’t have the luxury of a pre-defined syllabus.
Rapid retrieval of complex info into one ‘block’
I had the privilege of going to a seminar entitled ‘A Comment On How We Learn’ by the entertaining and engaging Aino Vonge Corry in 2015, during which I first learned about the concepts of chunking.
In her seminar, an example is given of an experiment with a novice being pitted against a chess-master to quickly memorise a board’s layout, and then reconstruct the board. As you might expect, the chess-master is much more adept at setting up the positions from memory than the novice.
Why? Because, during his lifetime of learning board configurations, the chess master had learned (encoded) vast numbers of logical board layouts, taking them from working memory to long term memory and back again (retrieval). The expert could conceptualise complex layouts in a single recall and recognise patterns.
Working memory vs long term memory
The ‘Learning how to Learn’ MOOC explains the difference between working and long memory well with the diagram below.
The ‘Octopus of Attention(3)’ shows how as you are working hard to process new information, you have 4 areas of working memory to you to process all this new information.
As you switch off, consolidate your understanding and learn, the memories (and the relationships between them) are built in your longer term memory, as shown on the right.
Illustration 1: Working memory vs long term memory
As you can see from the right hand side of the diagram, in the longer term memory, relationships have formed between some of the neurons. When the information and their relationships can be ‘recalled’ in a single ‘unit of learning’, you have a chunk, and this is the building block of your training.
You can’t ‘upload’ experience
Where the chess experiment really got interesting, was when a computer generated random board layouts, ones that made no sense. At this point the novice actually started to outperform the chess-master. Why? Because the chess-master couldn’t recall any encoded layout for something so ‘nonsensical’. The novice on the other hand had no patterns to struggle to recall so now they were on a level playing field in terms of experience.
Later in the seminar, we also get an explanation as to the frustration experienced when you are the teacher and the student doesn’t seem able to grasp the concept. It’s more than likely due to the fact that all the encoded chunks in the teachers brain, making things so easy to recall for the teacher, are the unique experience of that teacher.
In the diagram below, the person training you has developed the complex relationships between the concepts, what they are are capable of pulling into working memory
But what if you are the student?
Whilst the seminar was both vindicating (I didn’t feel bad for not getting stuff straight away) and enlightening to me, it was aimed at educating people who are training others. But it got me thinking- what happens, when you are the person who is being trained, who can’t seem to piece it all together? You feel bad for not getting concepts, and it’s quite hard to say ‘you’re training me wrong!’
Since we can’t ‘download’ our trainers experience, we will have to learn it for themselves. There’s no easy way if you want to get good at something. What we can do though, is give ourselves a head-start and start building ‘just enough’ knowledge to get ahead of the game.
So, how can developers use chunking?
In this article, I’ll cover a scenario that you might encounter in the workplace. Let’s say some work is coming up with a technology you’re not familiar with — and you’re under time pressure. If we can skim (but still retain) the fundamentals of a subject, we’re covered either way:
Requirement ends up not materialising, or gets assigned to someone else? You’ve still learnt something for the future that you’re highly like to use in a different context.
If it does end being you doing the work though, you’ve given yourself a head start, and can start diving in a bit deeper straight away.
Real world Scenario: The technology you’re expected to magically know
Giving an example from my work, the team I’m on is writing some integration software between us and an external vendor. The details aren’t especially important other than what we have will have to run in a way that can be scaled out, and at some point there is the possibility of a race condition. In other words, it will have to use whatever mechanisms there are for multi-threaded programming.
In this scenario, I had a few problems to deal with:
- I hadn’t done concurrent programming, in a long, long time — I hadn’t really needed to.
- Due to the nature of agile projects, it was likely, but not certain that we might pick up this requirement soon.
- Ideally an agile team won’t have just one person who can pick up the work.
- It’s going to take me time to learn what I need if it ends up being me picking it up.
Gather your materials
Since I knew I’d need to get up to speed on Threading and Concurrency, and I knew there would be coherent, structured training online, I could set up a system. All you need is the following:
- The material itself (https://docs.oracle.com/javase/tutorial/essential/concurrency in this case)
- A flashcard system (I used cram.com here)
- A pomodoro timer
- An hour of your time.
That’s it. Once you have these tools you can build your ‘’first pass’ material.
Search for summaries, start for questions
One the timer had started, I scanned through the page on the tutorial. For each page, I formed a question for my flashcards. I created a high level flashcard with a question for each slide. The excellent “Make it Stick”(4) has a great expression when recounting a case study for a military school in the US. When going through material ‘Start for questions, read for answers’ — in other words, what is the point of reading this slide?
Since this is an official training trail, you can be pretty sure that the pages are structured in a way that will give you at least one ‘takeaway’ per page.
When the material is a textbook you can do the same with reading the start of sections and the final summary in the chapter as a first pass.
Make your test question specific enough to push you
As an example, the very first page states:
“The Java platform is designed from the ground up to support concurrent programming, with basic concurrency support in the Java programming language and the Java class libraries. Since version 5.0, the Java platform has also included high-level concurrency APIs”
My first flashcard in this collection then became — ‘name 3 ways Java supports concurrency’.
I continued like this for 2 pomodoros, (with breaks) taking me to an hour spent overall. By then I built out a set of flashcards with specific questions on high-level concepts.
Set your reminders
Once I had this set of high level questions, I reviewed it the next morning and set up my ’spaced reminders’ using a GTD system (see my other article here for more on that). Using www.cram.com, I would test myself on the flashcards I had written.
Even during the ‘first recall’ the next morning, my brain was already ticking on how these high level pointers would fit into what I was doing at work.
This part has to be a judgement call for you and your workload. In my case, I extended my learning a little further ( a few more hours of coding with learning tests) to get a bit more in-depth as I suspected I might need the knowledge for my job. As an exercise, you might like to look at the concurrency trail with a pomodoro timer and see if you can spot which of my flashcards are obviously from a ‘first scan’.
Developing ‘just enough’ expertise
You might see from the slides given that there isn’t anything in there that would be specific to my job. Apart from the obvious restriction of not putting confidential work information into the public domain, I didn’t want to pollute these flashcards with specifics. It only has high level, generic concurrency concepts in there.
The number one reason for this is because of the nature of Agile projects. Time spent recording specifics into flashcards is time taken away from the development of working solutions. That’s certainly not to say that I didn’t use ‘learning tests’ to try and find out how an API worked for our project, far from it.
It’s just that at some point we actually have to try and build something ‘for real’, and I felt once we left the ground of fundamentals, then the experience would come from building and iterating the software rather than adding to my flashcards.
Likewise, if something changed about the implementation as new information was discovered during the project, recording flashcards for that might be wasted effort.
My ‘acid test’ for whether something should go onto a flashcard was:
‘Can I say, with what I know now, that I’ll definitively re-use this concept?’ — if no, it didn’t make the cut.
I found time boxing an invaluable technique to focus on getting the gist before diving any deeper into a subject. I used 25 minute blocks to get a ‘first scan’, but as a bare minimum you need to be building questions from each section.
On subsequent tests of the material, I adjusted the questions to more specific and probing, reflecting that I’d had more context now.
However the biggest win was with what I discarded — the biggest gain for me was learning how to quickly gain an overview and then zero in on specifics in my day to day job. I’ll always have the flashcards and learning tests for re-use, but I didn’t spend time on implementation details I’ll never use again — this freed me up for ‘direction changing’ on the project.
Your experiences of this approach
I’d really like to hear from you next. It would be great if you could respond to this article with how you got on with this approach, or what did and didn’t work for you. Likewise if you have any further questions on this, please respond in the comments section too.
Citations and References
1Vonge Corry, Aino. “A comment on how we learn” https://www.Youtube.Com/Watch?V=Ozyipg-Ox8y. 2017. Video.
3 Octopus of attention and diffuse tentacles, images, Kevin Mendez, 2014
4 Brown, Peter C, Roedinger III, Henry L, McDaniel, Mark A. “Tips for Teachers.” Make it Stick. Cambridge, Massaechusetts, London England: The Belknap Press of Harvard Press, 2014. Pages 234–235. Print.