A schema is a knowledge structure in a student's long-term memory (LTM). Schemas can:
Categorize things, like a schema for different types of computer games.
Represent procedures, like a schema for how to change a burned-out light-bulb.
Show the structure of things. A sandwich is two pieces of bread with stuff in the middle.
The sandwich schema is an abstraction of particular sandwich instances. The schema is a template, with slots for things that vary. For example, the sandwich schema has a slot for "filling." I recommend Vegemite.
Looking for patterns in things and events is natural for humans. It's a primary cognitive process, that is, schema abstraction is baked into us by evolution.
Schemas are central to human expertise. When examining a new situation, we automatically find schemas that might apply. "Automatic" means the process takes little cognitive effort. In a sense, expert problem solving is largely memory in disguise.
Think about a chess master playing a dozen amateurs simultaneously. They're not superhumans, analyzing thousands of future moves per second. Instead, the master's automatic cognitive processes are finding schemas that match the current board. The match isn't on the exact position of every piece, but on strategic attributes of the arrangement, like "control of the center," and "knight on the edge of the board."
Skilling helps you give schemas a central role in your course, if you want to go in that direction. Skilling explicitly represents three types of schemas:
Patterns: ways of doing things
Principles: general rules applying across tasks contexts
Models: descriptions of objects and processes
A pattern is a schema for doing something. For example, here are two data representation examples:
... we can abstract the Record pattern.
Patterns often contain other patterns. We can group records to form the Record Set pattern.
Each pattern is a separate data object in Skilling, with its own page and fields. When you write lessons, you can use insert pattern summaries. Summaries include links to pattern pages. Here's a with a summary of the Record Set pattern.
You can explain a pattern in a lesson, then refer to it again and again in later lessons. Patterns have a psychological existence separate from particular lessons. Patterns become thinking tools, as they are for experts.
Suppose a lesson explains a pattern, then gives an exercise to reinforce the pattern. It's obvious to students which pattern to use; it's the one in the lesson.
That's OK to start with, but isn't where we want to be. We want students to choose patterns based on the tasks they face, when they don't have lesson cues.
At the end of each module (chapter) in a course, I have exercises that are separate from lessons. Like the end-of-chapter exercises in a textbook. I expect students to find relevant patterns. Patterns can be from any prior lesson in the course.
Ideally, students would remember all the patterns, but that's not realistic. Flipping back through lessons manually doesn't seem like a good use of their time. Too much like fishing for an answer. So...
Skilling has a pattern catalog. It's a list of the patterns in the course. Here's the first entry in the pattern catalog from a web apps course.
When students have an exercise in an exam, or some other out-of-lesson context, they can scan the pattern catalog, to remind them of the patterns they've learned. The last column, "Referenced in," shows the lessons where authors have inserted pattern summaries. If students want more details than the pattern pages have, they can jump to those lessons.
As with everything else, the Skilling software maintains the pattern catalog. Add a pattern, rename one, whatever, and the catalog is updated automatically. Software is good at that sort of thing.
Remember there are other schema types besides patterns
A principle is a general idea, often used to guide pattern instantiation. An example in programming is the DRY principle: don't repeat yourself. Write code once, and call it from different places.
A model is a taxonomy, or a description of a process. For example, how the CPU works is a model. It's part of the external world of the programmer. It works as it does, regardless of the programmer's goals.
Skilling has the same support for principles and models, as it does for patterns.
This is why Skilling rocks
We know schemas are central to skilled performance. So, Skilling helps authors write about schemas. It helps students learn and use schemas. Attention to schemas is one example of why Skilling is a great tool for skill courses.