Design for Educational Games -Critique 3
while True: learn()
Basic Information
while True: learn() (WTL) by Luden.io is a desktop game to simulate the experience of a machine learning developer using visual programming instead of writing code. This game was launched earlier this year after a Steam Early Access Campaign.
Brief Description
After facing a difficult bug in some code, you get up for a cup of coffee. While doing so, your cat jumps on the keyboard and debugs your code. You decide you need to be able to talk to your cat so you can learn how to code better which leads you toward learning machine learning.
while True: learn() tries to simulate machine learning development over time. You begin with Expert Systems, and work up toward Neural Networks moving through the history of machine learning development. Each level is a kind of sorting puzzle, where data flows through your algorithm and into predefined buckets. But you don’t code anything, all of the algorithms are made with drag-and-drop blocks that hook together in a web.
Educational Objectives
Prior Knowledge
The game does a fair amount of scaffolding, providing numerous tutorials on the interface itself and what components represent. There’s not necessarily a lot you’d need to know in the way of machine learning or programming for that matter as the game aims to teach you machine learning and there’s no programming required! It would likely be helpful to know how conditional operations work. It would help to know some of the lingo of programmers, but that’s mostly for the jokes (Cat Overflow…)
Anticipated Learning & Potential Transfer
WTL aims to get people to understand machine learning in the abstract. Players would not be ready to implement code (again, no coding done) but would equipped to discuss how machine learning works in its different historic forms. However, this kind of conceptual hurdle taught through this puzzle game could provide a solid foundation upon which learning ML would be easier.
Some techniques WTL aims to build a conceptual base for include various kinds of sorting and conditions, training models, and neural networks.
The history aspect I find kind of interesting. The skill tree is based on historic forms of ML and in that way you could say that WTL teaches how different forms of ML work and how ML has changed overtime.
As it’s teaching more abstract conceptual skills, potential transfer is possible to real domains. It would likely serve as a good base for students to then use something like TensorFlow and actually build a neural network.
Throughout the game, sources are placed linking out to real information on how ML topics work, mostly in a mathematical sense. There’s even a whole page on the menu screen aiming to get people to learn how ML works for real and where you can learn more about it, including Coursera, Google search results, Wikipedia and Youtube. All of these help to show that the puzzles in the game have real world applications.
MDA
Mechanics
The game has a lot of mechanics. There’s a lot of moving pieces so I’ll cover the basics.
On a typical problem screen, there’s a stage, a top row, and side bar. On the stage is a Input stream (left) and Output streams (right). The Input stream will have shapes or colored blocks labeled with a number. The Output streams will have a similar shape or block, but they are separated in some way compared to the input stream. Blocks and shapes are meant to represent real data.
In the sidebar, you can access Nodes. Nodes are the main mechanical element of the game, ranging in types that each sort in a different way (some need training, varying numbers of output and configurability). Nodes can be connected together by dragging and dropping green lines to the arrow symbols seen on Nodes, Input and Output streams. Nodes also have a speed associated which determines how fast they can make a decision. Nodes often have a configuration such as choosing what to output in each stream or an “Else”.
The sidebar contains several different types of Nodes, as well as configurations from past puzzles turned into a single Node.
In the top bar, a badge tells you how well you’ve done on this puzzle. Other information in the top bar imposes limitations and currency. Time constraints, number of nodes allowed on this puzzle, and how much money you have pose challenges.
Other mechanics include tutorial cards, challenge emails, and the skill tree.
Dynamics
Game play is narrative driven, as you’re slowly building a reputation as a machine learning specialist, solving increasingly complex problems brought about through email chains and Cat Overflow forum discussions.
As a puzzle game, you solve puzzles by dragging components from the sidebar and connecting them by dragging lines. Each component output can only handle one connection, but input can be connected from multiple outputs.
Nodes have to be configured in specific ways such as choosing the color or shape to filter out, and chaining them together such that the filtering works together is the main goal.
One other limitation that gives rise to some interesting dynamics is each Node’s speed — different types of Nodes can process data faster or slower (based roughly on the speed of each Node’s internal algorithm). Some Nodes are faster, but more complicated to work with. For example, using an Expert System is slow, 1 second per datum, but very accurate while Decision Trees are faster, 0.3 seconds per datum, but when used with multiple colors can get a bit mixed up leading to filters going wrong.
When you believe you have your algorithm set up properly, you can test it for free to see how it would perform on live data. When you feel ready you can run the data on a production server, where you’ll have to pay for server time, but typically make money back from the transaction. During a Test or Run, the data cubes flow along the paths provided, enter a Node, get processed and continue on their journey until they reach an Output stream. Output is tested for accuracy and fullness. Each cube that enters will make the stream more full, and any incorrect sorting leads to a decline in accuracy.
After shipping an algorithm to production, the data will flow against a timer. At the end of the timer, you’ll see a success or failure screen showing how well your algorithm stacked up. It details how much you spent on the server costs, how much time was spent and how good your output was.
Once you complete a puzzle, a new piece of the skill tree opens up allowing you to progress to next skills.
You can see from the image above, that the skill tree is structured like a timeline showing your progress through historic ML techniques.
Aesthetics
Challenge is the main aesthetic as this is quite purely a puzzle game. The main motivating factor of game play is increasingly complex puzzles that you try to solve. There’s some element of Narrative (trying to learn machine learning to build a device to talk to your cat), and a bit of Sensation as it’s highly pleasing to watch the data stream through all of the Nodes and sort themselves properly. But ultimately, and in an accurate portrayal of programming in my opinion, solving puzzles is hard and you have to want to get good at solving them.
You could possibly reason that there’s a bit of Discovery as well. There may not necessarily be only 1 way to solve each problem, so exploring how the game pieces interact and work together is productive to find better combinations. There’s also a separate stage called DLL where you can create a specialized component for use during the main game.
This stage allows you to place whatever components you’d like together to create what ever output you’d like. In the main game, this is accessible as a single component through the DLL Nodes piece of the sidebar. However, I feel that these are mostly in service of solving the puzzle challenges leading back to Challenge as the main mechanic.
Instructional Principles
Principle 1: Promote an abstract understanding of the problem-solving knowledge
This entire game is an abstraction of ML. Real machine learning is not done with convenient components or data represented as colorful squares. WTL shows the general ideas of how ML works and different ML approaches through an approachable, puzzle solving, code-free lens.
In reality, ML probably does much more than just sort pieces of information, but I have never done ML so I can not confirm that. However, I find this to be a more productive and engaging representation for coding than games that ask users to chain event calls together to move a block around. This game does require a more algorithm generation, which is more true to the nature of advanced coding techniques.
Principle 2: Linking
Integrate instructional components > no integration
We could consider each Node to be its own instructional component as each Node takes on the form of a different ML approach or a different computational unit. In that way, WTL asks players to combine approaches to solve problems. No single Node would be sufficient to solve every puzzle, even if one was used in conjunction. This is a fair analogy to programming, where different frameworks and approaches make more sense in different scenarios.
Principle 3: Generation Effect
Learning is enhanced when learners produce answers compared to having them recognize answers.
As learners have to come up with solutions to the puzzles, they effectively have to come up with the sorting algorithm that will be most accurate and fastest. This requires that learners understand what each Node does, how they work together, and how to organize multiple Nodes into the solution.
Synthesis and Critique
Overall, this game aims to teach an abstraction of the skills required to do ML. It provides a taste of algorithm design, ML approaches, the history of those approaches, and the freelancer lifestyle. I think it does a fairly good job of representing programming in an accessible way. One particular strength I’ve found is that the game doesn’t use “math” like numbers or iteration to represent the changes taking place via code. Many “block coding” games still ask students for specific sequences and use of mathematical operators which I feel is a misrepresentation of the deeper nature of programming, which is much more puzzle like. I’ve said in the past that programming takes as much math as as Sudoku, and that’s where WTL succeeds.
I think the game could do a better job of explaining how each Node works internally. Maybe there could be a first few stages about making the individual Nodes so understand how a Node decides, though that could be considered out of scope.
I also think that they keep this very abstract, even representing information as colors or shapes. This could lead to lack of transferability as it stays in the puzzle world and doesn’t relate deeply to development in CS.
Overall, I really like this game as an intro for novices. They keep repeating that this is realistic by showing in-game v real world scenarios (see below), but keep it light enough to be enjoyable and consumable. I found that after an hour of game play, and putting it down for a bit, I had come up with a solution to a puzzle I had skipped and wanted to get back to work on it.
