prfm programming 2

Prfm Programming Language #2

@yllan

……with English notes in blue!

Recaphttp://youtu.be/_pjoep6U3tg

Episode #1

•Spatially → Patterns

•Temporally → Animations

We can control our drawings with Prfm Programming Language both:

, which creates

• Position → [translate 500 100]

• Size → [scale 0.5]

• Orientation → [rotate 3.14159]

• Brush → [brush 3]

SpatiallyThis is what we’ve learnt in Episode 1: Make spatial changes to our drawings.

Repetition

[repeat 5] [draw 0] [scale 0.5 0.5][end]

Pattern!

By making repeated spatial changes, we can make visual patterns!

(This is what we’ve learnt in Episode 1)

How the language really works

Before we introduce how to make temporal changes,you have to understand:

The idea is simple. It’s called

What is a stack?

• First In, Last Out.

Imagine a pile of boxes. We can 1) put a new box, or 2) take out a box on top of the pile.

Since we always operate on the top, the box at the bottom can only be taken out until all of the boxes above it were taken out.

That’s an important property of a stack:

Example 1

Let’s see how stack works inPrfm Programming Language.

[4][2][3][add]

Consider the following code:

Remember? Prfm Programming Language commands are enclosed in brackets. We have four commands here.

[4][2][3][add]

Let’s look at the first command. Number enclosed in brackets is called “numeric literal.”

It will push the number to an invisible stack.

Let me plot the stack out: there we have a “4” on the stack.

[4][2][3][add]

Then we push a “2” on the stack.

[4][2][3][add]

“3”, so on and so forth.

Notice the stack is in the reverse order of the code execution.

[4][2][3][add]

Now here is the interesting part. We want to add things. “But adding what?” you may wonder.

[4][2][3][add ]

It will add things on the stack. (Does that surprise you?)

Addition requires two numbers. We first pop the top element, a.k.a. “3”, out of the stack.

Then fill it into the last “placeholder.”

[4][2][3][add ]

Similarly, we pop out the second number from the stack, fill it into the first “placeholder.”

* Keep in mind that the fill-in order is reverse to the pop-out order. It doesn’t matter in this case because 2 + 3 = 3 + 2. But in non-commutative operations (e.g. subtraction, division), the order matters.

[4][2][3][add]

Once we have enough numbers to add, it calculates 2 + 3 = 5.

Where does our result go? You’re right.We push it back to stack.

Example 2

[100][200][translate]

Suppose we’ve already push 100 and 200 into stack. Let’s start with the 3rd line.

In episode 1, we’ve learnt the translate command. It takes two numbers, x and y respectively.

[100][200][translate ]

As we demonstrate in Example 1, we take the top number from stack and fill it in the last placeholder.

[100][200][translate ]100 200

…continually take number from stack and fill it in placeholder.

[100][200][translate ]100 200

[translate 100 200]

It is identical to the following code––what we’ve learnt in episode 1.

Since this ☝ work fine, why bother manipulating stack?

[brush 3][draw 0]

[brush][draw]

Well, if you write down the number explicitly, the command will always execute the same. But if you leave the number on stack, the translation amount will no longer a constant––it depends on the result of previous calculation. That’s more flexible.

Always use brush #3 to draw drawing #0

Depends on what’s on stack. Use brush #X to draw drawing #Y.

You can control that.

Example 3

OK. Now let’s see how repetition actually work.

[3][repeat] [brush 0] [draw 0][end]

We’ve seen this code in episode 1.

It will draw the same drawing at the same location three times. Since they all coincide, the result looks exactly as drawing only one time.

OK. We’ve push 3 into stack.

[3][repeat ] [brush 0] [draw 0][end]

The repeat command will take a number from stack, compare it to zero.

If it’s greater than zero, then minus one and push it back to stack.

Use brush #0

Draw drawing #0

2Jump to the matching [repeat].

If it’s greater than zero, then minus one and push it back to stack.

……and so on and so forth.

If it’s greater than zero, then…

Oh no! It’s no longer greater than zero.

Just jump to the next command of the matching [end].

Finished.

Example 4

Now you know how the repetition work.

[3][repeat] [brush] [draw 0][end]

The previous example is boring. We want to use different brushes each times.

Let’s change the [brush 0] to [brush]. It will use what’s on stack as the brush number. We’ve observed that the value of the top element decrease each time in the loop.

This should work, right?

Spoiler: no. Why not?

[3][repeat ] [brush] [draw 0][end]

Compare to zero, greater, minus one, put it back.

Pop the number from stack, filled into the last placeholder.

[3][repeat] [brush ] [draw 0][end]

2 Ok. Use brush #2.

Draw #0

[3][repeat] [brush] [draw 0][end] Jump back to the matching

[repeat].

Compare to zero……Wait, there is nothing left on stack!

Nothing to compare. Jump to the next command of the matching [end].

Program finished.

Do you see the problem? [brush] “ate” the number that is used by [repeat].

ref / remove

So here comes the principle:

Don’t eat others lunch unless you’re sure no one will starve.

We introduce two commands to manipulate the stack. You can copy/delete one element on stack.

ref / remove