TamaroCards - A Tangible Way to Compose Programs

Version 2, September 2024

PyTamaro is often used to teach complete novices. For them, writing Python code on a computer can be challenging. To support novices in reasoning about a graphic and its composition, we developed TamaroCards. Each Python function, constant, or operator is represented by a card. The cards can be arranged on a table to compose a Python expression that corresponds to a graphic.

TamaroCards

Literals are white empty pieces of paper, constants are blue rectangles, functions are red rounded rectangles, and operators are green circles.

Function cards are the most important. They are needed to produce or compose graphics. They represent calls to functions such as rectangle. Functions have parameters (arrows on the left), and we need to provide an argument for each parameter. We use cards to specify the arguments. Some arguments can simply be given literally, using an empty white Literal card onto which students write the corresponding literal value (such as 250, or "ciao"). For other arguments we want to use constants, such as the predefined constants for the base colors (e.g., red) We provide Constant cards for those. More advanced TamaroCard expressions may involve operators (like +, -, *, and /). We provide Operator cards for Python's most important unary, binary, and ternary operators.

Composing Cards into Expressions

To express a computation (i.e., the creation of a graphic), students connect together individual cards into an expression. They can place cards next to each other, and where necessary they can draw connecting lines between them.

To enable the drawing of connecting lines (and possible annotations), it is best to arrange the cards on a big piece of paper. We found that taping packaging paper on top of students' desks works particularly well.

Evaluating Expressions

The evaluation of a TamaroCard expression flows from left to right. Each constant, function, and operator emits a value on its right. Function arguments enter functions from the left, and, similarly, operands enter operators from the left.

Students can annotate the visual expression with the values emitted by the cards. They don't necessarily need to annotate each card: showing the values produced by the literal cards (which literally are the values written on the card) doesn't add any information; and showing the values produced by the constant cards (like colors) may not add much either. We usually focus on annotating values that are graphics, either by drawing that graphic, or by producing and placing a paper cut-out of that graphic.

Translating Cards to Python Code

Once students understand the meaning of cards and their compositions, it makes sense to transition from TamaroCards to Python source code.

We can translate a TamaroCard expression into a Python source expression using a systematic approach: a depth-first traversal of the tree. We draw a line (let's call it a "street") through the tree to make the traversal explicit. We start at the root of the tree (the rightmost card). Whenever we visit a function card for the first time, we write down the function's name followed by an opening parenthesis. Between each of a card's arguments, we write down a comma. And when we visit the card the last time, we write down a closing parenthesis.

Printable Documentation Pages

When using the TamaroCards, we provide each student (or student team) with the "documentation" in the form of a few printed pages.

Each documentation page shows a specific set of cards. These pages correspond to the library and language documentation: they explain what each function, constant, or operator does. The explanations are provided in a visual form: showing example arguments and return values of functions, example operands and results of operators, and the specific values of constants. This documentation should be sufficient to remember how to use the cards.

Students use the documentation pages as a reference when they try to understand the meaning of a specific card. Using these pages is training students to use reference documentation. We often initially distribute the Primitives and Colors pages, then the Combinators page, and later provide more pages as needed.

Printable Card Sheets

The six sheets contain cards arranged in a way so they can be printed and easily cut out. The sheets contain more copies of more commonly needed cards.

ConstantsConstant cards (blue), and empty white cards for primitive literals

FunctionsAll PyTamaro function cards (red)

CommonCommon PyTamaro function cards (red)

NamesCards for definition and use of own constants and functions

PythonOperatorsCards for common Python operators (green)

PythonFunctionsCards cards for common Python functions (red)

Note that the individual cards, unlike the documentation, do not contain any annotations on parameters, return values, or constant values. This is akin to code: when you call a function, you just write its name and provide arguments.

Individual Cards

We recommend printing the above sheets and cutting out the cards. However, if needed, one can download the ZIP file which contains an individual PDF, SVG, and PNG file for each card. This can be helpful, e.g., if you use a whiteboard application to work with the cards.

• Individual Cards

  Packaged in a ZIP file

Individual Documentation Pictures

In some situations it can make sense to include task-specific subsets of the documentation in teaching material. For example, you may write a Word document with an exercise for your students, and include the documentation of just those cards that are needed for that exercise. For this purpose, we also include individual pictures files of the documentation of each card. You can download the ZIP file which contains individual PDF, SVG, and PNG documentation pictures.

• Individual Documentation Pictures

  Packaged in a ZIP file

When NOT To Use TamaroCards

TamaroCards are designed for composing relatively simple Python expressions, mostly involving calls to PyTamaro functions. However, when including the function definition cards (from the "Names" card sheet), and the if-else card (from the "Operators" card sheet), TamaroCards actually represent a Turing-complete programming language!

You can implement any algorithm with TamaroCards. Even algorithms for which you normally would use loops! Why? Because loops are not the only way to repeat computations. There are other ways, one of them being recursion. And TamaroCards could be used to define recursive functions.

TamaroCards focus on a functional subset of Python: they contain pure functions (except show_graphic) and immutable variables (which we call constants). We recommend to use TamaroCards at the very start of a programming course for explaining pure expressions, constant definitions, and the definition of pure functions.

And once you introduce imperative Python features, such as mutable variables or loops in Python, you go beyond the TamaroCard notional machine. You can still use them, but only to reason about the pure and immutable parts of the code.

Working With TamaroCards Can Prevent Misconceptions

Teaching students to compose programs using TamaroCards, and translating TamaroCard expressions to Python code systematically, helps to combat known Python programming misconceptions, such as OutsideInFunctionNesting, NoAtomicExpression, and ParenthesesOnlyIfArgument.

TamaroCards: A Variant of the "Expression As Tree" Notional Machine

The "Expression as Tree" notional machine visually represents expressions as trees. Expression Tutor is an online platform built around that notional machine. It's goal is to help students understand the structure, evaluation, and typing of expressions. While the expression trees in Expression Tutor look different from TamaroCard expression trees, they are equivalent in many ways. TamaroCards are a specialized, unplugged, variant of the "Expression as Tree" notional machine, with a focus on expressions that are used to produce PyTamaro graphics.

Natural Languages

The PyTamaro API currently exists in four different natural languages: English, German, Italian, and French. Each TamaroCard shows its function or constant name in three of these supported languages (English, German, and Italian). This is ideal for multi-lingual environments. A future version may include the French names as well.

Prior Version of TamaroCards

You can find the prior version of TamaroCards here:

• Version 1

  August 2023